Autres/audacity
1
0
Fork 0
mirror of https://github.com/cookiengineer/audacity synced 2025-06-16 16:10:06 +02:00
Code Issues Releases Wiki Activity

Do the separation of classes ProjectWindow and AudacityProject

Browse Source
This commit is contained in:
Paul Licameli 2019-05-28 15:12:31 -04:00
parent 135af0480e
commit 4abc71c6b4
10 changed files with 466 additions and 372 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

2
lib-src/mod-nyq-bench/NyqBench.cpp
View File

@ -187,7 +187,7 @@ extern "C"
CommandManager *c = &CommandManager::Get( *p ); CommandManager *c = &CommandManager::Get( *p );
wxASSERT(c != NULL); wxASSERT(c != NULL);
wxMenuBar * pBar = p->GetMenuBar(); wxMenuBar * pBar = GetProjectFrame( *p ).GetMenuBar();
wxASSERT(pBar != NULL ); wxASSERT(pBar != NULL );
wxMenu * pMenu = pBar->GetMenu( 9 ); // Menu 9 is the Tools Menu. wxMenu * pMenu = pBar->GetMenu( 9 ); // Menu 9 is the Tools Menu.
wxASSERT( pMenu != NULL ); wxASSERT( pMenu != NULL );

433
src/Project.cpp
View File

@ -7,33 +7,6 @@
Dominic Mazzoni Dominic Mazzoni
Vaughan Johnson Vaughan Johnson
*******************************************************************//**
\file Project.cpp
\brief Implements AudacityProject
*//****************************************************************//**
\class AudacityProject
\brief AudacityProject provides the main window, with tools and
tracks contained within it.
In Audacity, the main window you work in is called a project.
AudacityProjects can contain an arbitrary number of tracks of many
different types, but if a project contains just one or two
tracks then it can be saved in standard formats like WAV or AIFF.
This window is the one that contains the menu bar (except on
the Mac).
\attention The menu functions for AudacityProject, those for creating
the menu bars and acting on clicks, are found in file Menus.cpp
*//****************************************************************//**
\class ViewInfo
\brief ViewInfo is used mainly to hold the zooming, selection and
scroll information. It also has some status flags.
*//*******************************************************************/ *//*******************************************************************/
#include "Audacity.h" // for USE_* macros #include "Audacity.h" // for USE_* macros
@ -556,74 +529,45 @@ enum {
NextID, NextID,
}; };
int AudacityProject::NextWindowID() int ProjectWindow::NextWindowID()
{ {
return mNextWindowID++; return mNextWindowID++;
} }
BEGIN_EVENT_TABLE(AudacityProject, wxFrame) BEGIN_EVENT_TABLE(ProjectWindow, wxFrame)
EVT_MENU(wxID_ANY, AudacityProject::OnMenu) EVT_MENU(wxID_ANY, ProjectWindow::OnMenu)
EVT_MOUSE_EVENTS(AudacityProject::OnMouseEvent) EVT_MOUSE_EVENTS(ProjectWindow::OnMouseEvent)
EVT_CLOSE(AudacityProject::OnCloseWindow) EVT_CLOSE(ProjectWindow::OnCloseWindow)
EVT_SIZE(AudacityProject::OnSize) EVT_SIZE(ProjectWindow::OnSize)
EVT_SHOW(AudacityProject::OnShow) EVT_SHOW(ProjectWindow::OnShow)
EVT_ICONIZE(AudacityProject::OnIconize) EVT_ICONIZE(ProjectWindow::OnIconize)
EVT_MOVE(AudacityProject::OnMove) EVT_MOVE(ProjectWindow::OnMove)
EVT_ACTIVATE(AudacityProject::OnActivate) EVT_ACTIVATE(ProjectWindow::OnActivate)
EVT_COMMAND_SCROLL_LINEUP(HSBarID, AudacityProject::OnScrollLeftButton) EVT_COMMAND_SCROLL_LINEUP(HSBarID, ProjectWindow::OnScrollLeftButton)
EVT_COMMAND_SCROLL_LINEDOWN(HSBarID, AudacityProject::OnScrollRightButton) EVT_COMMAND_SCROLL_LINEDOWN(HSBarID, ProjectWindow::OnScrollRightButton)
EVT_COMMAND_SCROLL(HSBarID, AudacityProject::OnScroll) EVT_COMMAND_SCROLL(HSBarID, ProjectWindow::OnScroll)
EVT_COMMAND_SCROLL(VSBarID, AudacityProject::OnScroll) EVT_COMMAND_SCROLL(VSBarID, ProjectWindow::OnScroll)
// Fires for menu with ID #1...first menu defined // Fires for menu with ID #1...first menu defined
EVT_UPDATE_UI(1, AudacityProject::OnUpdateUI) EVT_UPDATE_UI(1, ProjectWindow::OnUpdateUI)
EVT_ICONIZE(AudacityProject::OnIconize) EVT_COMMAND(wxID_ANY, EVT_TOOLBAR_UPDATED, ProjectWindow::OnToolBarUpdate)
EVT_COMMAND(wxID_ANY, EVT_TOOLBAR_UPDATED, AudacityProject::OnToolBarUpdate)
//mchinen:multithreaded calls - may not be threadsafe with CommandEvent: may have to change. //mchinen:multithreaded calls - may not be threadsafe with CommandEvent: may have to change.
END_EVENT_TABLE() END_EVENT_TABLE()
AudacityProject::AudacityProject(wxWindow * parent, wxWindowID id, ProjectWindow::ProjectWindow(wxWindow * parent, wxWindowID id,
const wxPoint & pos, const wxPoint & pos,
const wxSize & size) const wxSize & size, AudacityProject &project)
: wxFrame(parent, id, _TS("Audacity"), pos, size) : wxFrame(parent, id, _TS("Audacity"), pos, size)
, mProject{ project }
{ {
auto &project = *this; project.SetFrame( this );
auto &window = project;
mNextWindowID = NextID; mNextWindowID = NextID;
#ifdef EXPERIMENTAL_DA2 // Two sub-windows need to be made before Init(),
SetBackgroundColour(theTheme.Colour( clrMedium )); // so that this construcator can complete, and then TrackPanel and
#endif // AdornedRulerPanel can retrieve those windows from this in their
// Note that the first field of the status bar is a dummy, and it's width is set // factory functions
// to zero latter in the code. This field is needed for wxWidgets 2.8.12 because
// if you move to the menu bar, the first field of the menu bar is cleared, which
// is undesirable behaviour.
// In addition, the help strings of menu items are by default sent to the first
// field. Currently there are no such help strings, but it they were introduced, then
// there would need to be an event handler to send them to the appropriate field.
auto statusBar = CreateStatusBar(4);
#if wxUSE_ACCESSIBILITY
// so that name can be set on a standard control
statusBar->SetAccessible(safenew WindowAccessible(statusBar));
#endif
statusBar->SetName(wxT("status_line")); // not localized
mProjectNo = mProjectCounter++; // Bug 322
auto &viewInfo = ViewInfo::Get( *this );
mLockPlayRegion = false;
// LLL: Read this!!!
//
// Until the time (and cpu) required to refresh the track panel is
// reduced, leave the following window creations in the order specified.
// This will place the refresh of the track panel last, allowing all
// the others to get done quickly.
//
// Near as I can tell, this is only a problem under Windows.
//
// PRL: this panel groups the top tool dock and the ruler into one // PRL: this panel groups the top tool dock and the ruler into one
// tab cycle. // tab cycle.
@ -641,19 +585,6 @@ AudacityProject::AudacityProject(wxWindow * parent, wxWindowID id,
mTopPanel->SetBackgroundColour(theTheme.Colour( clrMedium )); mTopPanel->SetBackgroundColour(theTheme.Colour( clrMedium ));
#endif #endif
//
// Create the ToolDock
//
ToolManager::Get( project ).LayoutToolBars();
//
// Create the horizontal ruler
//
auto &ruler = AdornedRulerPanel::Get( project );
//
// Create the TrackPanel and the scrollbars
//
wxWindow * pPage; wxWindow * pPage;
#ifdef EXPERIMENTAL_NOTEBOOK #ifdef EXPERIMENTAL_NOTEBOOK
@ -693,6 +624,57 @@ AudacityProject::AudacityProject(wxWindow * parent, wxWindowID id,
mMainPage = pPage; mMainPage = pPage;
mPlaybackScroller = std::make_unique<PlaybackScroller>( &project );
}
void ProjectWindow::Init()
{
auto &project = mProject;
#ifdef EXPERIMENTAL_DA2
SetBackgroundColour(theTheme.Colour( clrMedium ));
#endif
// Note that the first field of the status bar is a dummy, and its width is set
// to zero latter in the code. This field is needed for wxWidgets 2.8.12 because
// if you move to the menu bar, the first field of the menu bar is cleared, which
// is undesirable behaviour.
// In addition, the help strings of menu items are by default sent to the first
// field. Currently there are no such help strings, but it they were introduced, then
// there would need to be an event handler to send them to the appropriate field.
auto statusBar = CreateStatusBar(4);
#if wxUSE_ACCESSIBILITY
// so that name can be set on a standard control
statusBar->SetAccessible(safenew WindowAccessible(statusBar));
#endif
statusBar->SetName(wxT("status_line")); // not localized
auto &viewInfo = ViewInfo::Get( project );
// LLL: Read this!!!
//
// Until the time (and cpu) required to refresh the track panel is
// reduced, leave the following window creations in the order specified.
// This will place the refresh of the track panel last, allowing all
// the others to get done quickly.
//
// Near as I can tell, this is only a problem under Windows.
//
//
// Create the ToolDock
//
ToolManager::Get( project ).LayoutToolBars();
//
// Create the horizontal ruler
//
auto &ruler = AdornedRulerPanel::Get( project );
//
// Create the TrackPanel and the scrollbars
//
{ {
auto ubs = std::make_unique<wxBoxSizer>(wxVERTICAL); auto ubs = std::make_unique<wxBoxSizer>(wxVERTICAL);
ubs->Add( ToolManager::Get( project ).GetTopDock(), 0, wxEXPAND | wxALIGN_TOP ); ubs->Add( ToolManager::Get( project ).GetTopDock(), 0, wxEXPAND | wxALIGN_TOP );
@ -700,6 +682,8 @@ AudacityProject::AudacityProject(wxWindow * parent, wxWindowID id,
mTopPanel->SetSizer(ubs.release()); mTopPanel->SetSizer(ubs.release());
} }
const auto pPage = GetMainPage();
wxBoxSizer *bs; wxBoxSizer *bs;
{ {
auto ubs = std::make_unique<wxBoxSizer>(wxVERTICAL); auto ubs = std::make_unique<wxBoxSizer>(wxVERTICAL);
@ -714,8 +698,6 @@ AudacityProject::AudacityProject(wxWindow * parent, wxWindowID id,
auto &trackPanel = TrackPanel::Get( project ); auto &trackPanel = TrackPanel::Get( project );
mPlaybackScroller = std::make_unique<PlaybackScroller>(this);
// LLL: When Audacity starts or becomes active after returning from // LLL: When Audacity starts or becomes active after returning from
// another application, the first window that can accept focus // another application, the first window that can accept focus
// will be given the focus even if we try to SetFocus(). By // will be given the focus even if we try to SetFocus(). By
@ -780,7 +762,7 @@ AudacityProject::AudacityProject(wxWindow * parent, wxWindowID id,
mMainPanel->Layout(); mMainPanel->Layout();
wxASSERT( trackPanel.GetProject()==this); wxASSERT( trackPanel.GetProject() == &project );
// MM: Give track panel the focus to ensure keyboard commands work // MM: Give track panel the focus to ensure keyboard commands work
trackPanel.SetFocus(); trackPanel.SetFocus();
@ -818,38 +800,103 @@ AudacityProject::AudacityProject(wxWindow * parent, wxWindowID id,
wxString msg = wxString::Format(_("Welcome to Audacity version %s"), wxString msg = wxString::Format(_("Welcome to Audacity version %s"),
AUDACITY_VERSION_STRING); AUDACITY_VERSION_STRING);
statusBar->SetStatusText(msg, mainStatusBarField); statusBar->SetStatusText(msg, mainStatusBarField);
ControlToolBar::Get( project ).UpdateStatusBar(this); ControlToolBar::Get( project ).UpdateStatusBar( &project );
wxTheApp->Bind(EVT_THEME_CHANGE, &AudacityProject::OnThemeChange, this); wxTheApp->Bind(EVT_THEME_CHANGE, &ProjectWindow::OnThemeChange, this);
#ifdef EXPERIMENTAL_DA2 #ifdef EXPERIMENTAL_DA2
ClearBackground();// For wxGTK. ClearBackground();// For wxGTK.
#endif #endif
}
AudacityProject::AudacityProject()
{
mProjectNo = mProjectCounter++; // Bug 322
AttachedObjects::BuildAll(); AttachedObjects::BuildAll();
// But not for the attached windows. They get built only on demand, such as // But not for the attached windows. They get built only on demand, such as
// from menu items. // from menu items.
} }
AudacityProject::~AudacityProject() AudacityProject::~AudacityProject()
{
}
namespace {
AudacityProject::AttachedWindows::RegisteredFactory sProjectWindowKey{
[]( AudacityProject &parent ) -> wxWeakRef< wxWindow > {
wxRect wndRect;
bool bMaximized = false;
bool bIconized = false;
GetNextWindowPlacement(&wndRect, &bMaximized, &bIconized);
auto pWindow = safenew ProjectWindow(
nullptr, -1,
wxDefaultPosition,
wxSize(wndRect.width, wndRect.height),
parent
);
auto &window = *pWindow;
// wxGTK3 seems to need to require creating the window using default position
// and then manually positioning it.
window.SetPosition(wndRect.GetPosition());
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);
}
return pWindow;
}
};
}
ProjectWindow &ProjectWindow::Get( AudacityProject &project )
{
return project.AttachedWindows::Get< ProjectWindow >( sProjectWindowKey );
}
const ProjectWindow &ProjectWindow::Get( const AudacityProject &project )
{
return Get( const_cast< AudacityProject & >( project ) );
}
ProjectWindow *ProjectWindow::Find( AudacityProject *pProject )
{
return pProject
? pProject->AttachedWindows::Find< ProjectWindow >( sProjectWindowKey )
: nullptr;
}
const ProjectWindow *ProjectWindow::Find( const AudacityProject *pProject )
{
return Find( const_cast< AudacityProject * >( pProject ) );
}
ProjectWindow::~ProjectWindow()
{ {
// Tool manager gives us capture sometimes // Tool manager gives us capture sometimes
if(HasCapture()) if(HasCapture())
ReleaseMouse(); ReleaseMouse();
} }
void AudacityProject::ApplyUpdatedTheme() void ProjectWindow::ApplyUpdatedTheme()
{ {
auto &project = *this; auto &project = mProject;
auto &trackPanel = TrackPanel::Get( project ); auto &trackPanel = TrackPanel::Get( project );
SetBackgroundColour(theTheme.Colour( clrMedium )); SetBackgroundColour(theTheme.Colour( clrMedium ));
ClearBackground();// For wxGTK. ClearBackground();// For wxGTK.
trackPanel.ApplyUpdatedTheme(); trackPanel.ApplyUpdatedTheme();
} }
void AudacityProject::RedrawProject(const bool bForceWaveTracks /*= false*/) void ProjectWindow::RedrawProject(const bool bForceWaveTracks /*= false*/)
{ {
auto &project = *this; auto &project = mProject ;
auto &tracks = TrackList::Get( project ); auto &tracks = TrackList::Get( project );
auto &trackPanel = TrackPanel::Get( project ); auto &trackPanel = TrackPanel::Get( project );
FixScrollbars(); FixScrollbars();
@ -862,18 +909,18 @@ void AudacityProject::RedrawProject(const bool bForceWaveTracks /*= false*/)
trackPanel.Refresh(false); trackPanel.Refresh(false);
} }
void AudacityProject::RefreshCursor() void ProjectWindow::RefreshCursor()
{ {
auto &project = *this; auto &project = mProject;
auto &trackPanel = TrackPanel::Get( project ); auto &trackPanel = TrackPanel::Get( project );
trackPanel.HandleCursorForPresentMouseState(); trackPanel.HandleCursorForPresentMouseState();
} }
void AudacityProject::OnThemeChange(wxCommandEvent& evt) void ProjectWindow::OnThemeChange(wxCommandEvent& evt)
{ {
evt.Skip(); evt.Skip();
auto &project = *this; auto &project = mProject;
ProjectWindow::Get( project ).ApplyUpdatedTheme(); this->ApplyUpdatedTheme();
auto &toolManager = ToolManager::Get( project ); auto &toolManager = ToolManager::Get( project );
for( int ii = 0; ii < ToolBarCount; ++ii ) for( int ii = 0; ii < ToolBarCount; ++ii )
{ {
@ -896,7 +943,7 @@ wxString AudacityProject::GetProjectName() const
return name; return name;
} }
void AudacityProject::FinishAutoScroll() void ProjectWindow::FinishAutoScroll()
{ {
// Set a flag so we don't have to generate two update events // Set a flag so we don't have to generate two update events
mAutoScrolling = true; mAutoScrolling = true;
@ -908,14 +955,13 @@ void AudacityProject::FinishAutoScroll()
mAutoScrolling = false; mAutoScrolling = false;
} }
/// ///
/// This method handles general left-scrolling, either for drag-scrolling /// This method handles general left-scrolling, either for drag-scrolling
/// or when the scrollbar is clicked to the left of the thumb /// or when the scrollbar is clicked to the left of the thumb
/// ///
void AudacityProject::OnScrollLeft() void ProjectWindow::OnScrollLeft()
{ {
auto &project = *this; auto &project = mProject;
auto &viewInfo = ViewInfo::Get( project ); auto &viewInfo = ViewInfo::Get( project );
wxInt64 pos = mHsbar->GetThumbPosition(); wxInt64 pos = mHsbar->GetThumbPosition();
// move at least one scroll increment // move at least one scroll increment
@ -936,9 +982,9 @@ void AudacityProject::OnScrollLeft()
/// or when the scrollbar is clicked to the right of the thumb /// or when the scrollbar is clicked to the right of the thumb
/// ///
void AudacityProject::OnScrollRight() void ProjectWindow::OnScrollRight()
{ {
auto &project = *this; auto &project = mProject;
auto &viewInfo = ViewInfo::Get( project ); auto &viewInfo = ViewInfo::Get( project );
wxInt64 pos = mHsbar->GetThumbPosition(); wxInt64 pos = mHsbar->GetThumbPosition();
// move at least one scroll increment // move at least one scroll increment
@ -957,12 +1003,13 @@ void AudacityProject::OnScrollRight()
} }
} }
/// ///
/// This handles the event when the left direction button on the scrollbar is depresssed /// This handles the event when the left direction button on the scrollbar is depresssed
/// ///
void AudacityProject::OnScrollLeftButton(wxScrollEvent & /*event*/) void ProjectWindow::OnScrollLeftButton(wxScrollEvent & /*event*/)
{ {
auto &project = *this; auto &project = mProject;
auto &viewInfo = ViewInfo::Get( project ); auto &viewInfo = ViewInfo::Get( project );
wxInt64 pos = mHsbar->GetThumbPosition(); wxInt64 pos = mHsbar->GetThumbPosition();
// move at least one scroll increment // move at least one scroll increment
@ -981,9 +1028,9 @@ void AudacityProject::OnScrollLeftButton(wxScrollEvent & /*event*/)
/// ///
/// This handles the event when the right direction button on the scrollbar is depresssed /// This handles the event when the right direction button on the scrollbar is depresssed
/// ///
void AudacityProject::OnScrollRightButton(wxScrollEvent & /*event*/) void ProjectWindow::OnScrollRightButton(wxScrollEvent & /*event*/)
{ {
auto &project = *this; auto &project = mProject;
auto &viewInfo = ViewInfo::Get( project ); auto &viewInfo = ViewInfo::Get( project );
wxInt64 pos = mHsbar->GetThumbPosition(); wxInt64 pos = mHsbar->GetThumbPosition();
// move at least one scroll increment // move at least one scroll increment
@ -1003,9 +1050,9 @@ void AudacityProject::OnScrollRightButton(wxScrollEvent & /*event*/)
} }
bool AudacityProject::MayScrollBeyondZero() const bool ProjectWindow::MayScrollBeyondZero() const
{ {
auto &project = *this; auto &project = mProject;
auto &scrubber = Scrubber::Get( project ); auto &scrubber = Scrubber::Get( project );
auto &viewInfo = ViewInfo::Get( project ); auto &viewInfo = ViewInfo::Get( project );
if (viewInfo.bScrollBeyondZero) if (viewInfo.bScrollBeyondZero)
@ -1024,9 +1071,9 @@ bool AudacityProject::MayScrollBeyondZero() const
return false; return false;
} }
double AudacityProject::ScrollingLowerBoundTime() const double ProjectWindow::ScrollingLowerBoundTime() const
{ {
auto &project = *this; auto &project = mProject;
auto &tracks = TrackList::Get( project ); auto &tracks = TrackList::Get( project );
auto &trackPanel = TrackPanel::Get( project ); auto &trackPanel = TrackPanel::Get( project );
auto &viewInfo = ViewInfo::Get( project ); auto &viewInfo = ViewInfo::Get( project );
@ -1038,9 +1085,9 @@ double AudacityProject::ScrollingLowerBoundTime() const
// PRL: Bug1197: we seem to need to compute all in double, to avoid differing results on Mac // PRL: Bug1197: we seem to need to compute all in double, to avoid differing results on Mac
// That's why ViewInfo::TimeRangeToPixelWidth was defined, with some regret. // That's why ViewInfo::TimeRangeToPixelWidth was defined, with some regret.
double AudacityProject::PixelWidthBeforeTime(double scrollto) const double ProjectWindow::PixelWidthBeforeTime(double scrollto) const
{ {
auto &project = *this; auto &project = mProject;
auto &viewInfo = ViewInfo::Get( project ); auto &viewInfo = ViewInfo::Get( project );
const double lowerBound = ScrollingLowerBoundTime(); const double lowerBound = ScrollingLowerBoundTime();
return return
@ -1048,9 +1095,9 @@ double AudacityProject::PixelWidthBeforeTime(double scrollto) const
viewInfo.TimeRangeToPixelWidth(scrollto - lowerBound); viewInfo.TimeRangeToPixelWidth(scrollto - lowerBound);
} }
void AudacityProject::SetHorizontalThumb(double scrollto) void ProjectWindow::SetHorizontalThumb(double scrollto)
{ {
auto &project = *this; auto &project = mProject;
auto &viewInfo = ViewInfo::Get( project ); auto &viewInfo = ViewInfo::Get( project );
const auto unscaled = PixelWidthBeforeTime(scrollto); const auto unscaled = PixelWidthBeforeTime(scrollto);
const int max = mHsbar->GetRange() - mHsbar->GetThumbSize(); const int max = mHsbar->GetRange() - mHsbar->GetThumbSize();
@ -1071,7 +1118,7 @@ void AudacityProject::SetHorizontalThumb(double scrollto)
// This method, like the other methods prefaced with TP, handles TrackPanel // This method, like the other methods prefaced with TP, handles TrackPanel
// 'callback'. // 'callback'.
// //
void AudacityProject::TP_ScrollWindow(double scrollto) void ProjectWindow::TP_ScrollWindow(double scrollto)
{ {
SetHorizontalThumb(scrollto); SetHorizontalThumb(scrollto);
@ -1085,7 +1132,7 @@ void AudacityProject::TP_ScrollWindow(double scrollto)
// handler in Track Panel. A positive argument makes the window // handler in Track Panel. A positive argument makes the window
// scroll down, while a negative argument scrolls up. // scroll down, while a negative argument scrolls up.
// //
bool AudacityProject::TP_ScrollUpDown(int delta) bool ProjectWindow::TP_ScrollUpDown(int delta)
{ {
int oldPos = mVsbar->GetThumbPosition(); int oldPos = mVsbar->GetThumbPosition();
int pos = oldPos + delta; int pos = oldPos + delta;
@ -1111,9 +1158,9 @@ bool AudacityProject::TP_ScrollUpDown(int delta)
return false; return false;
} }
void AudacityProject::FixScrollbars() void ProjectWindow::FixScrollbars()
{ {
auto &project = *this; auto &project = mProject;
auto &tracks = TrackList::Get( project ); auto &tracks = TrackList::Get( project );
auto &trackPanel = TrackPanel::Get( project ); auto &trackPanel = TrackPanel::Get( project );
auto &viewInfo = ViewInfo::Get( project ); auto &viewInfo = ViewInfo::Get( project );
@ -1273,9 +1320,9 @@ void AudacityProject::FixScrollbars()
} ); } );
} }
void AudacityProject::UpdateLayout() void ProjectWindow::UpdateLayout()
{ {
auto &project = *this; auto &project = mProject;
auto &trackPanel = TrackPanel::Get( project ); auto &trackPanel = TrackPanel::Get( project );
auto &toolManager = ToolManager::Get( project ); auto &toolManager = ToolManager::Get( project );
@ -1303,7 +1350,7 @@ void AudacityProject::UpdateLayout()
SetSizeHints(250, (mainsz.y - sbpos.y) + tppos.y + 50, 20000, 20000); SetSizeHints(250, (mainsz.y - sbpos.y) + tppos.y + 50, 20000, 20000);
} }
void AudacityProject::HandleResize() void ProjectWindow::HandleResize()
{ {
// Activate events can fire during window teardown, so just // Activate events can fire during window teardown, so just
// ignore them. // ignore them.
@ -1311,14 +1358,18 @@ void AudacityProject::HandleResize()
return; return;
} }
auto &project = *this;
FixScrollbars(); FixScrollbars();
UpdateLayout(); UpdateLayout();
} }
void AudacityProject::OnIconize(wxIconizeEvent &event)
bool ProjectWindow::IsIconized() const
{
return mIconized;
}
void ProjectWindow::OnIconize(wxIconizeEvent &event)
{ {
//JKC: On Iconizing we get called twice. Don't know //JKC: On Iconizing we get called twice. Don't know
// why but it does no harm. // why but it does no harm.
@ -1349,14 +1400,14 @@ void AudacityProject::OnIconize(wxIconizeEvent &event)
OnShow( Evt ); OnShow( Evt );
} }
void AudacityProject::OnMove(wxMoveEvent & event) void ProjectWindow::OnMove(wxMoveEvent & event)
{ {
if (!this->IsMaximized() && !this->IsIconized()) if (!this->IsMaximized() && !this->IsIconized())
SetNormalizedWindowState(this->GetRect()); SetNormalizedWindowState(this->GetRect());
event.Skip(); event.Skip();
} }
void AudacityProject::OnSize(wxSizeEvent & event) void ProjectWindow::OnSize(wxSizeEvent & event)
{ {
// (From Debian) // (From Debian)
// //
@ -1374,7 +1425,7 @@ void AudacityProject::OnSize(wxSizeEvent & event)
event.Skip(); event.Skip();
} }
void AudacityProject::OnShow(wxShowEvent & event) void ProjectWindow::OnShow(wxShowEvent & event)
{ {
// Remember that the window has been shown at least once // Remember that the window has been shown at least once
mShownOnce = true; mShownOnce = true;
@ -1414,16 +1465,16 @@ void AudacityProject::OnShow(wxShowEvent & event)
/// ///
/// A toolbar has been updated, so handle it like a sizing event. /// A toolbar has been updated, so handle it like a sizing event.
/// ///
void AudacityProject::OnToolBarUpdate(wxCommandEvent & event) void ProjectWindow::OnToolBarUpdate(wxCommandEvent & event)
{ {
HandleResize(); HandleResize();
event.Skip(false); /* No need to propagate any further */ event.Skip(false); /* No need to propagate any further */
} }
void AudacityProject::OnScroll(wxScrollEvent & WXUNUSED(event)) void ProjectWindow::OnScroll(wxScrollEvent & WXUNUSED(event))
{ {
auto &project = *this; auto &project = mProject;
auto &viewInfo = ViewInfo::Get( project ); auto &viewInfo = ViewInfo::Get( project );
const wxInt64 offset = PixelWidthBeforeTime(0.0); const wxInt64 offset = PixelWidthBeforeTime(0.0);
viewInfo.sbarH = viewInfo.sbarH =
@ -1431,9 +1482,9 @@ void AudacityProject::OnScroll(wxScrollEvent & WXUNUSED(event))
DoScroll(); DoScroll();
} }
void AudacityProject::DoScroll() void ProjectWindow::DoScroll()
{ {
auto &project = *this; auto &project = mProject;
auto &trackPanel = TrackPanel::Get( project ); auto &trackPanel = TrackPanel::Get( project );
auto &viewInfo = ViewInfo::Get( project ); auto &viewInfo = ViewInfo::Get( project );
const double lowerBound = ScrollingLowerBoundTime(); const double lowerBound = ScrollingLowerBoundTime();
@ -1471,7 +1522,7 @@ void AudacityProject::DoScroll()
} ); } );
} }
void AudacityProject::OnMenu(wxCommandEvent & event) void ProjectWindow::OnMenu(wxCommandEvent & event)
{ {
#ifdef __WXMSW__ #ifdef __WXMSW__
// Bug 1642: We can arrive here with bogus menu IDs, which we // Bug 1642: We can arrive here with bogus menu IDs, which we
@ -1486,7 +1537,7 @@ void AudacityProject::OnMenu(wxCommandEvent & event)
return; return;
} }
#endif #endif
auto &project = *this; auto &project = mProject;
auto &commandManager = CommandManager::Get( project ); auto &commandManager = CommandManager::Get( project );
bool handled = commandManager.HandleMenuID( bool handled = commandManager.HandleMenuID(
event.GetId(), MenuManager::Get( project ).GetUpdateFlags( project ), event.GetId(), MenuManager::Get( project ).GetUpdateFlags( project ),
@ -1500,13 +1551,13 @@ void AudacityProject::OnMenu(wxCommandEvent & event)
} }
} }
void AudacityProject::OnUpdateUI(wxUpdateUIEvent & WXUNUSED(event)) void ProjectWindow::OnUpdateUI(wxUpdateUIEvent & WXUNUSED(event))
{ {
auto &project = *this; auto &project = mProject;
MenuManager::Get( project ).UpdateMenus( project ); MenuManager::Get( project ).UpdateMenus( project );
} }
void AudacityProject::MacShowUndockedToolbars(bool show) void ProjectWindow::MacShowUndockedToolbars(bool show)
{ {
(void)show;//compiler food (void)show;//compiler food
#ifdef __WXMAC__ #ifdef __WXMAC__
@ -1524,7 +1575,7 @@ void AudacityProject::MacShowUndockedToolbars(bool show)
#endif #endif
} }
void AudacityProject::OnActivate(wxActivateEvent & event) void ProjectWindow::OnActivate(wxActivateEvent & event)
{ {
// Activate events can fire during window teardown, so just // Activate events can fire during window teardown, so just
// ignore them. // ignore them.
@ -1532,7 +1583,7 @@ void AudacityProject::OnActivate(wxActivateEvent & event)
return; return;
} }
auto &project = *this; auto &project = mProject;
mActive = event.GetActive(); mActive = event.GetActive();
@ -1555,7 +1606,7 @@ void AudacityProject::OnActivate(wxActivateEvent & event)
} }
else { else {
auto &toolManager = ToolManager::Get( project ); auto &toolManager = ToolManager::Get( project );
SetActiveProject(this); SetActiveProject( &project );
if ( ! toolManager.RestoreFocus() ) if ( ! toolManager.RestoreFocus() )
TrackPanel::Get( project ).SetFocus(); TrackPanel::Get( project ).SetFocus();
@ -1566,15 +1617,16 @@ void AudacityProject::OnActivate(wxActivateEvent & event)
event.Skip(); event.Skip();
} }
bool AudacityProject::IsActive() bool ProjectWindow::IsActive()
{ {
return mActive; return mActive;
} }
void AudacityProject::OnMouseEvent(wxMouseEvent & event) void ProjectWindow::OnMouseEvent(wxMouseEvent & event)
{ {
auto &project = mProject;
if (event.ButtonDown()) if (event.ButtonDown())
SetActiveProject(this); SetActiveProject( &project );
} }
static void RefreshAllTitles(bool bShowProjectNumbers ) static void RefreshAllTitles(bool bShowProjectNumbers )
@ -1587,14 +1639,15 @@ static void RefreshAllTitles(bool bShowProjectNumbers )
} }
} }
TitleRestorer::TitleRestorer(AudacityProject * p ) TitleRestorer::TitleRestorer(ProjectWindow * pWindow )
{ {
auto &window = GetProjectFrame( *p ); auto &window = *pWindow;
if( window.IsIconized() ) if( window.IsIconized() )
window.Restore(); window.Restore();
window.Raise(); // May help identifying the window on Mac window.Raise(); // May help identifying the window on Mac
// Construct this projects name and number. // Construct this projects name and number.
auto p = &pWindow->GetProject();
sProjName = p->GetProjectName(); sProjName = p->GetProjectName();
if (sProjName.empty()){ if (sProjName.empty()){
sProjName = _("<untitled>"); sProjName = _("<untitled>");
@ -1618,12 +1671,12 @@ TitleRestorer::~TitleRestorer() {
RefreshAllTitles( false ); RefreshAllTitles( false );
} }
void AudacityProject::ZoomAfterImport(Track *pTrack) void ProjectWindow::ZoomAfterImport(Track *pTrack)
{ {
auto &project = *this; auto &project = mProject;
auto &trackPanel = TrackPanel::Get( project ); auto &trackPanel = TrackPanel::Get( project );
ViewActions::DoZoomFit(*this); ViewActions::DoZoomFit( project );
trackPanel.SetFocus(); trackPanel.SetFocus();
RedrawProject(); RedrawProject();
@ -1633,9 +1686,9 @@ void AudacityProject::ZoomAfterImport(Track *pTrack)
} }
// Utility function called by other zoom methods // Utility function called by other zoom methods
void AudacityProject::Zoom(double level) void ProjectWindow::Zoom(double level)
{ {
auto &project = *this; auto &project = mProject;
auto &viewInfo = ViewInfo::Get( project ); auto &viewInfo = ViewInfo::Get( project );
viewInfo.SetZoom(level); viewInfo.SetZoom(level);
FixScrollbars(); FixScrollbars();
@ -1652,9 +1705,9 @@ void AudacityProject::Zoom(double level)
} }
// Utility function called by other zoom methods // Utility function called by other zoom methods
void AudacityProject::ZoomBy(double multiplier) void ProjectWindow::ZoomBy(double multiplier)
{ {
auto &project = *this; auto &project = mProject;
auto &viewInfo = ViewInfo::Get( project ); auto &viewInfo = ViewInfo::Get( project );
viewInfo.ZoomBy(multiplier); viewInfo.ZoomBy(multiplier);
FixScrollbars(); FixScrollbars();
@ -1668,9 +1721,9 @@ void AudacityProject::ZoomBy(double multiplier)
// selection to 0 (holding right edge constant), otherwise it will // selection to 0 (holding right edge constant), otherwise it will
// move both left and right edge of selection to 0 // move both left and right edge of selection to 0
/////////////////////////////////////////////////////////////////// ///////////////////////////////////////////////////////////////////
void AudacityProject::Rewind(bool shift) void ProjectWindow::Rewind(bool shift)
{ {
auto &project = *this; auto &project = mProject;
auto &viewInfo = ViewInfo::Get( project ); auto &viewInfo = ViewInfo::Get( project );
viewInfo.selectedRegion.setT0(0, false); viewInfo.selectedRegion.setT0(0, false);
if (!shift) if (!shift)
@ -1688,9 +1741,9 @@ void AudacityProject::Rewind(bool shift)
// selection to the end (holding left edge constant), otherwise it will // selection to the end (holding left edge constant), otherwise it will
// move both left and right edge of selection to the end // move both left and right edge of selection to the end
/////////////////////////////////////////////////////////////////// ///////////////////////////////////////////////////////////////////
void AudacityProject::SkipEnd(bool shift) void ProjectWindow::SkipEnd(bool shift)
{ {
auto &project = *this; auto &project = mProject;
auto &tracks = TrackList::Get( project ); auto &tracks = TrackList::Get( project );
auto &trackPanel = TrackPanel::Get( project ); auto &trackPanel = TrackPanel::Get( project );
auto &viewInfo = ViewInfo::Get( project ); auto &viewInfo = ViewInfo::Get( project );
@ -1712,19 +1765,19 @@ void AudacityProject::SetStatus(const wxString &msg)
if ( msg != mLastMainStatusMessage ) { if ( msg != mLastMainStatusMessage ) {
mLastMainStatusMessage = msg; mLastMainStatusMessage = msg;
wxCommandEvent evt{ EVT_PROJECT_STATUS_UPDATE }; wxCommandEvent evt{ EVT_PROJECT_STATUS_UPDATE };
project.GetEventHandler()->ProcessEvent( evt ); project.ProcessEvent( evt );
} }
} }
void AudacityProject::TP_DisplaySelection() void ProjectWindow::TP_DisplaySelection()
{ {
auto &project = *this; auto &project = mProject;
auto &ruler = AdornedRulerPanel::Get(project); auto &ruler = AdornedRulerPanel::Get(project);
auto &viewInfo = ViewInfo::Get( project ); auto &viewInfo = ViewInfo::Get( project );
const auto &selectedRegion = viewInfo.selectedRegion; const auto &selectedRegion = viewInfo.selectedRegion;
double audioTime; double audioTime;
if (!gAudioIO->IsBusy() && !mLockPlayRegion) if (!gAudioIO->IsBusy() && project.IsPlayRegionLocked())
ruler.SetPlayRegion( selectedRegion.t0(), selectedRegion.t1() ); ruler.SetPlayRegion( selectedRegion.t0(), selectedRegion.t1() );
else else
// Cause ruler redraw anyway, because we may be zooming or scrolling // Cause ruler redraw anyway, because we may be zooming or scrolling
@ -1734,7 +1787,7 @@ void AudacityProject::TP_DisplaySelection()
audioTime = gAudioIO->GetStreamTime(); audioTime = gAudioIO->GetStreamTime();
else { else {
double playEnd; double playEnd;
GetPlayRegion(&audioTime, &playEnd); project.GetPlayRegion(&audioTime, &playEnd);
} }
SelectionBar::Get( project ).SetTimes(selectedRegion.t0(), SelectionBar::Get( project ).SetTimes(selectedRegion.t0(),
@ -1747,24 +1800,24 @@ void AudacityProject::TP_DisplaySelection()
// TrackPanel callback method // TrackPanel callback method
void AudacityProject::TP_ScrollLeft() void ProjectWindow::TP_ScrollLeft()
{ {
OnScrollLeft(); OnScrollLeft();
} }
// TrackPanel callback method // TrackPanel callback method
void AudacityProject::TP_ScrollRight() void ProjectWindow::TP_ScrollRight()
{ {
OnScrollRight(); OnScrollRight();
} }
// TrackPanel callback method // TrackPanel callback method
void AudacityProject::TP_RedrawScrollbars() void ProjectWindow::TP_RedrawScrollbars()
{ {
FixScrollbars(); FixScrollbars();
} }
void AudacityProject::TP_HandleResize() void ProjectWindow::TP_HandleResize()
{ {
HandleResize(); HandleResize();
} }
@ -1777,7 +1830,7 @@ void AudacityProject::GetPlayRegion(double* playRegionStart,
playRegionStart, playRegionEnd); playRegionStart, playRegionEnd);
} }
AudacityProject::PlaybackScroller::PlaybackScroller(AudacityProject *project) ProjectWindow::PlaybackScroller::PlaybackScroller(AudacityProject *project)
: mProject(project) : mProject(project)
{ {
ViewInfo::Get( *mProject ).Bind(EVT_TRACK_PANEL_TIMER, ViewInfo::Get( *mProject ).Bind(EVT_TRACK_PANEL_TIMER,
@ -1785,7 +1838,7 @@ AudacityProject::PlaybackScroller::PlaybackScroller(AudacityProject *project)
this); this);
} }
void AudacityProject::PlaybackScroller::OnTimer(wxCommandEvent &event) void ProjectWindow::PlaybackScroller::OnTimer(wxCommandEvent &event)
{ {
// Let other listeners get the notification // Let other listeners get the notification
event.Skip(); event.Skip();
@ -1837,9 +1890,9 @@ void AudacityProject::PlaybackScroller::OnTimer(wxCommandEvent &event)
} }
} }
void AudacityProject::ZoomInByFactor( double ZoomFactor ) void ProjectWindow::ZoomInByFactor( double ZoomFactor )
{ {
auto &project = *this; auto &project = mProject;
auto &trackPanel = TrackPanel::Get( project ); auto &trackPanel = TrackPanel::Get( project );
auto &viewInfo = ViewInfo::Get( project ); auto &viewInfo = ViewInfo::Get( project );
@ -1918,9 +1971,9 @@ void AudacityProject::ZoomInByFactor( double ZoomFactor )
TP_ScrollWindow(newh); TP_ScrollWindow(newh);
} }
void AudacityProject::ZoomOutByFactor( double ZoomFactor ) void ProjectWindow::ZoomOutByFactor( double ZoomFactor )
{ {
auto &project = *this; auto &project = mProject;
auto &trackPanel = TrackPanel::Get( project ); auto &trackPanel = TrackPanel::Get( project );
auto &viewInfo = ViewInfo::Get( project ); auto &viewInfo = ViewInfo::Get( project );
@ -1935,3 +1988,19 @@ void AudacityProject::ZoomOutByFactor( double ZoomFactor )
// newh = (newh > 0) ? newh : 0; // newh = (newh > 0) ? newh : 0;
TP_ScrollWindow(newh); TP_ScrollWindow(newh);
} }
wxFrame &GetProjectFrame( AudacityProject &project )
{
auto ptr = project.GetFrame();
if ( !ptr )
THROW_INCONSISTENCY_EXCEPTION;
return *ptr;
}
const wxFrame &GetProjectFrame( const AudacityProject &project )
{
auto ptr = project.GetFrame();
if ( !ptr )
THROW_INCONSISTENCY_EXCEPTION;
return *ptr;
}

365
src/Project.h
View File

@ -105,179 +105,35 @@ private:
class Track; class Track;
// Container of various objects associated with the project, which is class ProjectWindow final : public wxFrame
// responsible for destroying them , public TrackPanelListener
using AttachedObjects = ClientData::Site<
AudacityProject, ClientData::Base, ClientData::SkipCopying, std::shared_ptr
>;
// Container of pointers to various windows associated with the project, which
// is not responsible for destroying them -- wxWidgets handles that instead
using AttachedWindows = ClientData::Site<
AudacityProject, wxWindow, ClientData::SkipCopying, wxWeakRef
>;
using ProjectWindow = AudacityProject;
class AUDACITY_DLL_API AudacityProject final : public wxFrame,
public TrackPanelListener
, public AttachedObjects
, public AttachedWindows
{ {
public: public:
static ProjectWindow &Get( AudacityProject &project ) { return project; } static ProjectWindow &Get( AudacityProject &project );
static const ProjectWindow &Get( const AudacityProject &project ) { return project; } static const ProjectWindow &Get( const AudacityProject &project );
static ProjectWindow *Find( AudacityProject *pProject ) { return pProject; } static ProjectWindow *Find( AudacityProject *pProject );
static const ProjectWindow *Find( const AudacityProject *pProject ) { return pProject; } static const ProjectWindow *Find( const AudacityProject *pProject );
AudacityProject &GetProject() { return *this; } AudacityProject &GetProject() { return mProject; }
using AttachedObjects = ::AttachedObjects; explicit ProjectWindow(
using AttachedWindows = ::AttachedWindows; wxWindow * parent, wxWindowID id,
const wxPoint & pos, const wxSize &size,
AudacityProject(wxWindow * parent, wxWindowID id, AudacityProject &project );
const wxPoint & pos, const wxSize & size); ~ProjectWindow() override;
virtual ~AudacityProject();
// Next available ID for sub-windows // Next available ID for sub-windows
int NextWindowID(); int NextWindowID();
virtual void ApplyUpdatedTheme(); void Init();
void GetPlayRegion(double* playRegionStart, double *playRegionEnd);
bool IsPlayRegionLocked() { return mLockPlayRegion; }
void SetPlayRegionLocked(bool value) { mLockPlayRegion = value; }
wxString GetProjectName() const;
bool IsActive() override; bool IsActive() override;
bool IsIconized() const override;
using wxFrame::DetachMenuBar;
void ZoomAfterImport(Track *pTrack);
const FilePath &GetFileName() { return mFileName; }
void SetFileName( const FilePath &value ) { mFileName = value; }
wxWindow *GetMainPage() { return mMainPage; }
wxPanel *GetTopPanel() { return mTopPanel; }
// Message Handlers
void OnMenu(wxCommandEvent & event);
void OnUpdateUI(wxUpdateUIEvent & event);
void MacShowUndockedToolbars(bool show);
void OnActivate(wxActivateEvent & event);
void OnMouseEvent(wxMouseEvent & event);
void OnIconize(wxIconizeEvent &event);
void OnSize(wxSizeEvent & event);
void OnShow(wxShowEvent & event);
void OnMove(wxMoveEvent & event);
void DoScroll();
void OnScroll(wxScrollEvent & event);
void OnToolBarUpdate(wxCommandEvent & event);
void HandleResize();
void UpdateLayout();
void ZoomInByFactor( double ZoomFactor );
void ZoomOutByFactor( double ZoomFactor );
// Other commands
int GetProjectNumber(){ return mProjectNo;};
void RedrawProject(const bool bForceWaveTracks = false);
void RefreshCursor();
void Zoom(double level);
void ZoomBy(double multiplier);
void Rewind(bool shift);
void SkipEnd(bool shift);
// Scrollbars
void OnScrollLeft();
void OnScrollRight();
void OnScrollLeftButton(wxScrollEvent & event);
void OnScrollRightButton(wxScrollEvent & event);
void FinishAutoScroll();
void FixScrollbars();
bool MayScrollBeyondZero() const;
double ScrollingLowerBoundTime() const;
// How many pixels are covered by the period from lowermost scrollable time, to the given time:
// PRL: Bug1197: we seem to need to compute all in double, to avoid differing results on Mac
double PixelWidthBeforeTime(double scrollto) const;
void SetHorizontalThumb(double scrollto);
// TrackPanel callback methods, overrides of TrackPanelListener
void TP_DisplaySelection() override;
void TP_RedrawScrollbars() override;
void TP_ScrollLeft() override;
void TP_ScrollRight() override;
void TP_ScrollWindow(double scrollto) override;
bool TP_ScrollUpDown(int delta) override;
void TP_HandleResize() override;
const wxString &GetStatus() const { return mLastMainStatusMessage; }
void SetStatus(const wxString &msg);
private:
void OnThemeChange(wxCommandEvent & evt);
// The project's name and file info
FilePath mFileName; // Note: extension-less
static int mProjectCounter;// global counter.
int mProjectNo; // count when this project was created.
// Window elements
wxString mLastMainStatusMessage;
wxPanel *mTopPanel{};
wxWindow * mMainPage;
wxPanel * mMainPanel;
wxScrollBar *mHsbar;
wxScrollBar *mVsbar;
public:
wxScrollBar &GetVerticalScrollBar() { return *mVsbar; }
private:
int mNextWindowID;
bool mAutoScrolling{ false };
bool mActive{ true };
bool mIconized;
bool mShownOnce{ false };
public:
bool mbBusyImporting{ false }; // used to fix bug 584
int mBatchMode{ 0 };// 0 means not, >0 means in batch mode.
void SetNormalizedWindowState(wxRect pSizeAndLocation) { mNormalizedWindowState = pSizeAndLocation; }
wxRect GetNormalizedWindowState() const { return mNormalizedWindowState; }
private:
bool mIsDeleting{ false };
public:
bool IsBeingDeleted() const { return mIsDeleting; } bool IsBeingDeleted() const { return mIsDeleting; }
void SetIsBeingDeleted() { mIsDeleting = true; } void SetIsBeingDeleted() { mIsDeleting = true; }
private: wxWindow *GetMainPage() { return mMainPage; }
wxPanel *GetTopPanel() { return mTopPanel; }
bool mLockPlayRegion;
wxRect mNormalizedWindowState;
public:
bool mbInitializingScrollbar{ false };
class PlaybackScroller final : public wxEvtHandler class PlaybackScroller final : public wxEvtHandler
{ {
@ -303,20 +159,191 @@ public:
AudacityProject *mProject; AudacityProject *mProject;
Mode mMode { Mode::Off }; Mode mMode { Mode::Off };
}; };
PlaybackScroller &GetPlaybackScroller() { return *mPlaybackScroller; }
using wxFrame::DetachMenuBar;
void SetNormalizedWindowState(wxRect pSizeAndLocation) { mNormalizedWindowState = pSizeAndLocation; }
wxRect GetNormalizedWindowState() const { return mNormalizedWindowState; }
void RedrawProject(const bool bForceWaveTracks = false);
void RefreshCursor();
void Zoom(double level);
void ZoomInByFactor( double ZoomFactor );
void ZoomOutByFactor( double ZoomFactor );
void ZoomBy(double multiplier);
void ZoomAfterImport(Track *pTrack);
void ApplyUpdatedTheme();
// Scrollbars
wxScrollBar &GetVerticalScrollBar() { return *mVsbar; }
void OnScrollLeft();
void OnScrollRight();
void Rewind(bool shift);
void SkipEnd(bool shift);
void OnScrollLeftButton(wxScrollEvent & event);
void OnScrollRightButton(wxScrollEvent & event);
void FinishAutoScroll();
void FixScrollbars();
bool MayScrollBeyondZero() const;
double ScrollingLowerBoundTime() const;
// How many pixels are covered by the period from lowermost scrollable time, to the given time:
// PRL: Bug1197: we seem to need to compute all in double, to avoid differing results on Mac
double PixelWidthBeforeTime(double scrollto) const;
void SetHorizontalThumb(double scrollto);
// PRL: old and incorrect comment below, these functions are used elsewhere than TrackPanel
// TrackPanel access
wxSize GetTPTracksUsableArea() /* not override */;
void RefreshTPTrack(Track* pTrk, bool refreshbacking = true) /* not override */;
// TrackPanel callback methods, overrides of TrackPanelListener
void TP_DisplaySelection() override;
void TP_RedrawScrollbars() override;
void TP_ScrollLeft() override;
void TP_ScrollRight() override;
void TP_ScrollWindow(double scrollto) override;
bool TP_ScrollUpDown(int delta) override;
void TP_HandleResize() override;
private:
void OnThemeChange(wxCommandEvent & evt);
public:
// Message Handlers
void OnMenu(wxCommandEvent & event);
void OnUpdateUI(wxUpdateUIEvent & event);
void MacShowUndockedToolbars(bool show);
void OnActivate(wxActivateEvent & event);
void OnMouseEvent(wxMouseEvent & event);
void OnIconize(wxIconizeEvent &event);
void OnSize(wxSizeEvent & event);
void HandleResize();
void UpdateLayout();
void OnShow(wxShowEvent & event);
void OnMove(wxMoveEvent & event);
void DoScroll();
void OnScroll(wxScrollEvent & event);
void OnToolBarUpdate(wxCommandEvent & event);
bool mbInitializingScrollbar{ false };
private: private:
std::unique_ptr<PlaybackScroller> mPlaybackScroller; AudacityProject &mProject;
wxRect mNormalizedWindowState;
public: wxPanel *mTopPanel{};
PlaybackScroller &GetPlaybackScroller() { return *mPlaybackScroller; } wxWindow * mMainPage{};
wxPanel * mMainPanel{};
wxScrollBar *mHsbar{};
wxScrollBar *mVsbar{};
int mNextWindowID{};
bool mAutoScrolling{ false };
bool mActive{ true };
bool mIconized;
bool mShownOnce{ false };
bool mIsDeleting{ false };
private:
std::unique_ptr<PlaybackScroller> mPlaybackScroller;
DECLARE_EVENT_TABLE() DECLARE_EVENT_TABLE()
}; };
inline wxFrame &GetProjectFrame( AudacityProject &project ) { return project; } // Container of various objects associated with the project, which is
inline const wxFrame &GetProjectFrame( const AudacityProject &project ) { // responsible for destroying them
return project; using AttachedObjects = ClientData::Site<
} AudacityProject, ClientData::Base, ClientData::SkipCopying, std::shared_ptr
>;
// Container of pointers to various windows associated with the project, which
// is not responsible for destroying them -- wxWidgets handles that instead
using AttachedWindows = ClientData::Site<
AudacityProject, wxWindow, ClientData::SkipCopying, wxWeakRef
>;
class AUDACITY_DLL_API AudacityProject final
: public wxEvtHandler
, public AttachedObjects
, public AttachedWindows
{
public:
using AttachedObjects = ::AttachedObjects;
using AttachedWindows = ::AttachedWindows;
AudacityProject();
virtual ~AudacityProject();
wxFrame *GetFrame() { return mFrame; }
const wxFrame *GetFrame() const { return mFrame; }
void SetFrame( wxFrame *pFrame ) { mFrame = pFrame; }
void GetPlayRegion(double* playRegionStart, double *playRegionEnd);
bool IsPlayRegionLocked() { return mLockPlayRegion; }
void SetPlayRegionLocked(bool value) { mLockPlayRegion = value; }
wxString GetProjectName() const;
const FilePath &GetFileName() { return mFileName; }
void SetFileName( const FilePath &fileName ) { mFileName = fileName; }
// Timer Record Auto Save/Export Routines
static int GetOpenProjectCount();
// Message Handlers
// Other commands
int GetProjectNumber(){ return mProjectNo;};
static int CountUnnamed();
static void RefreshAllTitles(bool bShowProjectNumbers );
const wxString &GetStatus() const { return mLastMainStatusMessage; }
void SetStatus(const wxString &msg);
private:
// The project's name and file info
FilePath mFileName; // Note: extension-less
static int mProjectCounter;// global counter.
int mProjectNo; // count when this project was created.
public:
bool mbBusyImporting{ false }; // used to fix bug 584
int mBatchMode{ 0 };// 0 means not, >0 means in batch mode.
private:
bool mLockPlayRegion{ false };
wxString mLastMainStatusMessage;
wxWeakRef< wxFrame > mFrame{};
};
wxFrame &GetProjectFrame( AudacityProject &project );
const wxFrame &GetProjectFrame( const AudacityProject &project );
inline wxFrame *FindProjectFrame( AudacityProject *project ) { inline wxFrame *FindProjectFrame( AudacityProject *project ) {
return project ? &GetProjectFrame( *project ) : nullptr; return project ? &GetProjectFrame( *project ) : nullptr;
} }
@ -327,7 +354,7 @@ inline const wxFrame *FindProjectFrame( const AudacityProject *project ) {
// TitleRestorer restores project window titles to what they were, in its destructor. // TitleRestorer restores project window titles to what they were, in its destructor.
class TitleRestorer{ class TitleRestorer{
public: public:
TitleRestorer(AudacityProject * p ); TitleRestorer(ProjectWindow * pWindow );
~TitleRestorer(); ~TitleRestorer();
wxString sProjNumber; wxString sProjNumber;
wxString sProjName; wxString sProjName;

4
src/ProjectFileIO.cpp
View File

@ -1106,8 +1106,8 @@ bool ProjectFileIO::SaveAs(const wxString & newFileName, bool bWantSaveCopy /*=
bool ProjectFileIO::SaveAs(bool bWantSaveCopy /*= false*/, bool bLossless /*= false*/) bool ProjectFileIO::SaveAs(bool bWantSaveCopy /*= false*/, bool bLossless /*= false*/)
{ {
auto &project = mProject; auto &project = mProject;
auto &window = GetProjectFrame( project ); auto &window = ProjectWindow::Get( project );
TitleRestorer Restorer( &project ); // RAII TitleRestorer Restorer( &window ); // RAII
bool bHasPath = true; bool bHasPath = true;
wxFileName filename{ project.GetFileName() }; wxFileName filename{ project.GetFileName() };
// Save a copy of the project with 32-bit float tracks. // Save a copy of the project with 32-bit float tracks.

20
src/ProjectManager.cpp
View File

@ -361,19 +361,13 @@ AudacityProject *ProjectManager::New()
// Create and show a NEW project // Create and show a NEW project
// Use a non-default deleter in the smart pointer! // Use a non-default deleter in the smart pointer!
auto sp = AllProjects::value_type { auto sp = std::make_shared< AudacityProject >();
safenew AudacityProject(
nullptr, -1,
wxDefaultPosition,
wxSize(wndRect.width, wndRect.height)
),
Destroyer< AudacityProject > {}
};
AllProjects{}.Add( sp ); AllProjects{}.Add( sp );
auto p = sp.get(); auto p = sp.get();
auto &project = *p; auto &project = *p;
auto &projectManager = Get( project ); auto &projectManager = Get( project );
auto &window = GetProjectFrame( *p ); auto &window = ProjectWindow::Get( *p );
window.Init();
MissingAliasFilesDialog::SetShouldShow(true); MissingAliasFilesDialog::SetShouldShow(true);
MenuManager::Get( project ).CreateMenusAndCommands( project ); MenuManager::Get( project ).CreateMenusAndCommands( project );
@ -457,7 +451,7 @@ bool ProjectManager::SnapSelection()
{ {
auto &project = mProject; auto &project = mProject;
auto &settings = ProjectSettings::Get( project ); auto &settings = ProjectSettings::Get( project );
auto &window = project; auto &window = ProjectWindow::Get( project );
auto snapTo = settings.GetSnapTo(); auto snapTo = settings.GetSnapTo();
if (snapTo != SNAP_OFF) { if (snapTo != SNAP_OFF) {
auto &viewInfo = ViewInfo::Get( project ); auto &viewInfo = ViewInfo::Get( project );
@ -514,7 +508,7 @@ void ProjectManager::AS_SetSnapTo(int snap)
{ {
auto &project = mProject; auto &project = mProject;
auto &settings = ProjectSettings::Get( project ); auto &settings = ProjectSettings::Get( project );
auto &window = project; auto &window = ProjectWindow::Get( project );
settings.SetSnapTo( snap ); settings.SetSnapTo( snap );
@ -657,7 +651,7 @@ void ProjectManager::OnCloseWindow(wxCloseEvent & event)
const auto &settings = ProjectSettings::Get( project ); const auto &settings = ProjectSettings::Get( project );
auto &projectAudioIO = ProjectAudioIO::Get( project ); auto &projectAudioIO = ProjectAudioIO::Get( project );
auto &tracks = TrackList::Get( project ); auto &tracks = TrackList::Get( project );
auto &window = project; auto &window = ProjectWindow::Get( project );
// We are called for the wxEVT_CLOSE_WINDOW, wxEVT_END_SESSION, and // We are called for the wxEVT_CLOSE_WINDOW, wxEVT_END_SESSION, and
// wxEVT_QUERY_END_SESSION, so we have to protect against multiple // wxEVT_QUERY_END_SESSION, so we have to protect against multiple
@ -1980,7 +1974,7 @@ void ProjectManager::OnTimer(wxTimerEvent& WXUNUSED(event))
void ProjectManager::OnStatusChange( wxCommandEvent & ) void ProjectManager::OnStatusChange( wxCommandEvent & )
{ {
auto &project = mProject; auto &project = mProject;
auto &window = project; auto &window = GetProjectFrame( project );
const auto &msg = project.GetStatus(); const auto &msg = project.GetStatus();
window.GetStatusBar()->SetStatusText(msg, mainStatusBarField); window.GetStatusBar()->SetStatusText(msg, mainStatusBarField);

2
src/ProjectSettings.cpp
View File

@ -22,7 +22,7 @@ namespace {
{ {
wxCommandEvent e{ EVT_PROJECT_SETTINGS_CHANGE }; wxCommandEvent e{ EVT_PROJECT_SETTINGS_CHANGE };
e.SetInt( static_cast<int>( code ) ); e.SetInt( static_cast<int>( code ) );
project.GetEventHandler()->ProcessEvent( e ); project.ProcessEvent( e );
} }
} }

2
src/TrackPanel.cpp
View File

@ -501,7 +501,7 @@ void TrackPanel::OnTimer(wxTimerEvent& )
// Notify listeners for timer ticks // Notify listeners for timer ticks
{ {
wxCommandEvent e(EVT_TRACK_PANEL_TIMER); wxCommandEvent e(EVT_TRACK_PANEL_TIMER);
p->GetEventHandler()->ProcessEvent(e); p->ProcessEvent(e);
} }
DrawOverlays(false); DrawOverlays(false);

2
src/toolbars/ToolManager.h
View File

@ -34,7 +34,7 @@ class wxTimerEvent;
class wxWindow; class wxWindow;
class AudacityProject; class AudacityProject;
using ProjectWindow = AudacityProject; class ProjectWindow;
class ToolFrame; class ToolFrame;
//////////////////////////////////////////////////////////// ////////////////////////////////////////////////////////////

7
src/tracks/ui/Scrubbing.cpp
View File

@ -226,6 +226,7 @@ Scrubber::Scrubber(AudacityProject *project)
#endif #endif
, mProject(project) , mProject(project)
, mWindow( FindProjectFrame( project ) )
, mPoller { std::make_unique<ScrubPoller>(*this) } , mPoller { std::make_unique<ScrubPoller>(*this) }
, mOptions {} , mOptions {}
@ -234,7 +235,8 @@ Scrubber::Scrubber(AudacityProject *project)
wxTheApp->Bind wxTheApp->Bind
(wxEVT_ACTIVATE_APP, (wxEVT_ACTIVATE_APP,
&Scrubber::OnActivateOrDeactivateApp, this); &Scrubber::OnActivateOrDeactivateApp, this);
mProject->PushEventHandler(&mForwarder); if (mWindow)
mWindow->PushEventHandler(&mForwarder);
} }
Scrubber::~Scrubber() Scrubber::~Scrubber()
@ -244,7 +246,8 @@ Scrubber::~Scrubber()
mpThread->Delete(); mpThread->Delete();
#endif #endif
mProject->PopEventHandler(); if ( mWindow )
mWindow->PopEventHandler();
} }
namespace { namespace {

1
src/tracks/ui/Scrubbing.h
View File

@ -196,6 +196,7 @@ private:
#endif #endif
AudacityProject *mProject; AudacityProject *mProject;
wxWindowRef mWindow;
DECLARE_EVENT_TABLE() DECLARE_EVENT_TABLE()