Audacity 3.2.0
Classes | Public Member Functions | Static Public Member Functions | Private Types | Private Member Functions | Private Attributes | List of all members
ToolManager Class Referencefinal

class ToolManager More...

#include <ToolManager.h>

Inheritance diagram for ToolManager:
[legend]
Collaboration diagram for ToolManager:
[legend]

Classes

struct  TopPanelHook
 

Public Member Functions

 ToolManager (AudacityProject *parent)
 
 ToolManager (const ToolManager &)=delete
 
ToolManageroperator= (const ToolManager &)=delete
 
 ~ToolManager ()
 
void CreateWindows ()
 
void LayoutToolBars ()
 
bool IsDocked (Identifier type) const
 
bool IsVisible (Identifier type) const
 
void ShowHide (Identifier type)
 
void Expose (Identifier type, bool show)
 
ToolBarGetToolBar (const Identifier &type) const
 
ToolDockGetTopDock ()
 
const ToolDockGetTopDock () const
 
ToolDockGetBotDock ()
 
const ToolDockGetBotDock () const
 
void Reset ()
 
void Destroy ()
 
void RegenerateTooltips ()
 
int FilterEvent (wxEvent &event) override
 
bool RestoreFocus ()
 
template<typename F >
void ForEach (F &&fun)
 Visit bars, lexicographically by their textual ids. More...
 
size_t CountBars () const
 
- Public Member Functions inherited from ClientData::Base
virtual ~Base ()
 

Static Public Member Functions

static ToolManagerGet (AudacityProject &project)
 
static const ToolManagerGet (const AudacityProject &project)
 
static void OnResetToolBars (const CommandContext &context)
 
static void ModifyToolbarMenus (AudacityProject &project)
 
static void ModifyAllProjectToolbarMenus ()
 

Private Types

using FramePtr = Destroy_ptr< wxFrame >
 

Private Member Functions

ToolBarFloat (ToolBar *t, wxPoint &pos)
 
void OnMenuUpdate (struct MenuUpdateMessage)
 
void OnTimer (wxTimerEvent &event)
 
void OnMouse (wxMouseEvent &event)
 
void OnCaptureLost (wxMouseCaptureLostEvent &event)
 
void UndockBar (wxPoint mp)
 
void OnGrabber (GrabberEvent &event)
 
void HandleEscapeKey ()
 
void DoneDragging ()
 
void OnIndicatorCreate (wxWindowCreateEvent &event)
 
void OnIndicatorPaint (wxPaintEvent &event)
 
void ReadConfig ()
 
void WriteConfig ()
 
void Updated ()
 

Private Attributes

Observer::Subscription mMenuManagerSubscription
 
AudacityProjectmParent
 
wxWindowRef mLastFocus {}
 
ToolFramemDragWindow
 
ToolDockmDragDock
 
ToolBarmDragBar {}
 
wxPoint mDragOffset
 
ToolBarConfiguration::Position mDragBefore {}
 
wxPoint mLastPos
 
wxRect mBarPos
 
FramePtr mIndicator
 
std::unique_ptr< wxRegion > mLeft
 
std::unique_ptr< wxRegion > mDown
 
wxRegion * mCurrent
 
wxTimer mTimer
 
bool mLastState
 
bool mTransition
 
ToolDockmTopDock {}
 
ToolDockmBotDock {}
 
std::map< Identifier, ToolBar::HoldermBars
 map not unordered_map, for the promise made by ForEach More...
 
wxPoint mPrevPosition {}
 
ToolDockmPrevDock {}
 
ToolBarConfiguration::Position mPrevSlot { ToolBarConfiguration::UnspecifiedPosition }
 
ToolBarConfiguration mPrevConfiguration
 
bool mDidDrag {}
 
bool mClicked {}
 

Detailed Description

class ToolManager

Manages the ToolDocks and handles the dragging, floating, and docking of ToolBars.

Definition at line 52 of file ToolManager.h.

Member Typedef Documentation

◆ FramePtr

using ToolManager::FramePtr = Destroy_ptr<wxFrame>
private

Definition at line 152 of file ToolManager.h.

Constructor & Destructor Documentation

◆ ToolManager() [1/2]

ToolManager::ToolManager ( AudacityProject parent)

Definition at line 352 of file ToolManager.cpp.

353: wxEvtHandler()
354{
355 wxPoint pt[ 3 ];
356
357#if defined(__WXMAC__)
358 // Save original transition
359 mTransition = wxSystemOptions::GetOptionInt( wxMAC_WINDOW_PLAIN_TRANSITION );
360#endif
361
362 // Initialize everything
363 mParent = parent;
364 mLastPos.x = mBarPos.x = -1;
365 mLastPos.y = mBarPos.y = -1;
366 mDragWindow = NULL;
367 mDragDock = NULL;
368 mDragBar = NULL;
369
370 // Create the down arrow
371 pt[ 0 ].x = 0;
372 pt[ 0 ].y = 0;
373 pt[ 1 ].x = 9;
374 pt[ 1 ].y = 9;
375 pt[ 2 ].x = 18;
376 pt[ 2 ].y = 0;
377
378 // Create the shaped region
379 mDown = std::make_unique<wxRegion>( 3, &pt[0] );
380
381 // Create the down arrow
382 pt[ 0 ].x = 9;
383 pt[ 0 ].y = 0;
384 pt[ 1 ].x = 0;
385 pt[ 1 ].y = 9;
386 pt[ 2 ].x = 9;
387 pt[ 2 ].y = 18;
388
389 // Create the shaped region
390 mLeft = std::make_unique<wxRegion>( 3, &pt[0] );
391
392 // Create the indicator frame
393 // parent is null but FramePtr ensures destruction
394 mIndicator = FramePtr{ safenew wxFrame( NULL,
395 wxID_ANY,
396 wxEmptyString,
397 wxDefaultPosition,
398 wxSize( 32, 32 ),
399 wxFRAME_TOOL_WINDOW |
400 wxFRAME_SHAPED |
401 wxNO_BORDER |
402 wxFRAME_NO_TASKBAR |
403 wxSTAY_ON_TOP )
404 };
405
406 // Hook the creation event...only needed on GTK, but doesn't hurt for all
407 mIndicator->Bind( wxEVT_CREATE,
409 this );
410
411 // Hook the paint event...needed for all
412 mIndicator->Bind( wxEVT_PAINT,
414 this );
415
416 // It's a little shy
417 mIndicator->Hide();
418}
#define safenew
Definition: MemoryX.h:10
void OnIndicatorCreate(wxWindowCreateEvent &event)
ToolBar * mDragBar
Definition: ToolManager.h:145
bool mTransition
Definition: ToolManager.h:161
ToolFrame * mDragWindow
Definition: ToolManager.h:143
std::unique_ptr< wxRegion > mLeft
Definition: ToolManager.h:154
AudacityProject * mParent
Definition: ToolManager.h:140
void OnIndicatorPaint(wxPaintEvent &event)
std::unique_ptr< wxRegion > mDown
Definition: ToolManager.h:154
ToolDock * mDragDock
Definition: ToolManager.h:144
Destroy_ptr< wxFrame > FramePtr
Definition: ToolManager.h:152
wxRect mBarPos
Definition: ToolManager.h:150
FramePtr mIndicator
Definition: ToolManager.h:153
wxPoint mLastPos
Definition: ToolManager.h:149

References mBarPos, mDown, mDragBar, mDragDock, mDragWindow, mIndicator, mLastPos, mLeft, mParent, mTransition, OnIndicatorCreate(), OnIndicatorPaint(), and safenew.

Here is the call graph for this function:

◆ ToolManager() [2/2]

ToolManager::ToolManager ( const ToolManager )
delete

◆ ~ToolManager()

ToolManager::~ToolManager ( )

Definition at line 509 of file ToolManager.cpp.

510{
511 Destroy();
512}
void Destroy()

References Destroy().

Here is the call graph for this function:

Member Function Documentation

◆ CountBars()

size_t ToolManager::CountBars ( ) const
inline

Definition at line 110 of file ToolManager.h.

111 {
112 return mBars.size();
113 }
std::map< Identifier, ToolBar::Holder > mBars
map not unordered_map, for the promise made by ForEach
Definition: ToolManager.h:168

◆ CreateWindows()

void ToolManager::CreateWindows ( )

Assign (non-persistent!) sequential ids to the toolbars

Definition at line 420 of file ToolManager.cpp.

421{
422 auto parent = mParent;
423 auto &window = GetProjectFrame( *parent );
424
425 // Hook the parents mouse events...using the parent helps greatly
426 // under GTK
427 window.Bind( wxEVT_LEFT_UP,
429 this );
430 window.Bind( wxEVT_MOTION,
432 this );
433 window.Bind( wxEVT_MOUSE_CAPTURE_LOST,
435 this );
436
437 wxWindow *topDockParent = TopPanelHook::Call( window );
438 wxASSERT(topDockParent);
439
440 // Create the top and bottom docks
441 mTopDock = safenew ToolDock( this, topDockParent, TopDockID );
442 mBotDock = safenew ToolDock( this, &window, BotDockID );
443
444 // Create all of the toolbars
445 // All have the project as parent window
446 wxASSERT(parent);
447
448 for (const auto &factory : RegisteredToolbarFactory::GetFactories()) {
449 if (factory) {
450 auto bar = factory( *parent );
451 if (bar) {
452 auto &slot = mBars[bar->GetSection()];
453 if (slot) {
454 // Oh no, name collision of registered toolbars
455 assert(false);
456 bar->Destroy();
457 continue;
458 }
459 slot = std::move(bar);
460 }
461 }
462 else
463 wxASSERT( false );
464 }
465
467 ForEach([ii = 0](ToolBar *bar) mutable { bar->SetIndex(ii++); });
468
469 // We own the timer
470 mTimer.SetOwner( this );
471
472 // Process the toolbar config settings
473 ReadConfig();
474
475 wxEvtHandler::AddFilter(this);
476
479}
AUDACITY_DLL_API wxFrame & GetProjectFrame(AudacityProject &project)
Get the top-level window associated with the project (as a wxFrame only, when you do not need to use ...
@ BotDockID
Definition: ToolDock.h:44
@ TopDockID
Definition: ToolDock.h:43
static result_type Call(Arguments &&...arguments)
Null check of the installed function is done for you.
static MenuManager & Get(AudacityProject &project)
Definition: Menus.cpp:69
Subscription Subscribe(Callback callback)
Connect a callback to the Publisher; later-connected are called earlier.
Definition: Observer.h:199
Works with ToolManager and ToolDock to provide a dockable window in which buttons can be placed.
Definition: ToolBar.h:74
void SetIndex(int index)
Set a value used for computing cascading positions of undocked bars.
Definition: ToolBar.h:114
A dynamic panel where a ToolBar can be docked.
Definition: ToolDock.h:292
void OnMenuUpdate(struct MenuUpdateMessage)
void ReadConfig()
void OnCaptureLost(wxMouseCaptureLostEvent &event)
ToolDock * mTopDock
Definition: ToolManager.h:164
wxTimer mTimer
Definition: ToolManager.h:157
Observer::Subscription mMenuManagerSubscription
Definition: ToolManager.h:139
void ForEach(F &&fun)
Visit bars, lexicographically by their textual ids.
Definition: ToolManager.h:103
void OnMouse(wxMouseEvent &event)
ToolDock * mBotDock
Definition: ToolManager.h:165
static RegisteredToolbarFactory factory
static const Functions & GetFactories()
Definition: ToolBar.cpp:1047

References BotDockID, GlobalHook< TopPanelHook, wxWindow *(wxWindow &) >::Call(), cloud::factory, ForEach(), MenuManager::Get(), RegisteredToolbarFactory::GetFactories(), GetProjectFrame(), mBars, mBotDock, mMenuManagerSubscription, mParent, mTimer, mTopDock, OnCaptureLost(), OnMenuUpdate(), OnMouse(), ReadConfig(), safenew, ToolBar::SetIndex(), Observer::Publisher< Message, NotifyAll >::Subscribe(), and TopDockID.

Referenced by InitProjectWindow().

Here is the call graph for this function:
Here is the caller graph for this function:

◆ Destroy()

void ToolManager::Destroy ( )

Definition at line 485 of file ToolManager.cpp.

486{
487 if ( mTopDock || mBotDock ) { // destroy at most once
488 wxEvtHandler::RemoveFilter(this);
489
490 // Save the toolbar states
491 WriteConfig();
492
493 // This function causes the toolbars to be destroyed, so
494 // clear the configuration of the ToolDocks which refer to
495 // these toolbars. This change was needed to stop Audacity
496 // crashing when running with Jaws on Windows 10 1703.
499
500 mTopDock = mBotDock = nullptr; // indicate that it has been destroyed
501
502 for (auto &pair : mBars)
503 pair.second.reset();
504
505 mIndicator.reset();
506 }
507}
ToolBarConfiguration & GetConfiguration()
Definition: ToolDock.h:311
void WriteConfig()

References ToolBarConfiguration::Clear(), ToolDock::GetConfiguration(), mBars, mBotDock, mIndicator, mTopDock, and WriteConfig().

Referenced by ProjectManager::OnCloseWindow(), and ~ToolManager().

Here is the call graph for this function:
Here is the caller graph for this function:

◆ DoneDragging()

void ToolManager::DoneDragging ( )
private

Definition at line 1488 of file ToolManager.cpp.

1489{
1490 // Done dragging - ensure grabber button isn't pushed
1491 if( mDragBar )
1492 {
1493 mDragBar->SetDocked( mDragBar->GetDock(), false );
1494 }
1495
1496 // Release capture
1497 auto &window = GetProjectFrame( *mParent );
1498 if( window.HasCapture() )
1499 {
1500 window.ReleaseMouse();
1501 }
1502
1503 // Hide the indicator
1504 mIndicator->Hide();
1505
1506 mDragWindow = NULL;
1507 mDragDock = NULL;
1508 mDragBar = NULL;
1509 mPrevDock = NULL;
1512 mLastPos.x = mBarPos.x = -1;
1513 mLastPos.y = mBarPos.y = -1;
1514 mTimer.Stop();
1515 mDidDrag = false;
1516 mClicked = false;
1517
1518 RestoreFocus();
1519}
static const Position UnspecifiedPosition
Definition: ToolDock.h:106
virtual void SetDocked(ToolDock *dock, bool pushed)
Definition: ToolBar.cpp:661
ToolDock * GetDock()
Definition: ToolBar.cpp:647
ToolBarConfiguration mPrevConfiguration
Definition: ToolManager.h:174
ToolDock * mPrevDock
Definition: ToolManager.h:171
ToolBarConfiguration::Position mPrevSlot
Definition: ToolManager.h:173
bool RestoreFocus()

References ToolBarConfiguration::Clear(), ToolBar::GetDock(), GetProjectFrame(), mBarPos, mClicked, mDidDrag, mDragBar, mDragDock, mDragWindow, mIndicator, mLastPos, mParent, mPrevConfiguration, mPrevDock, mPrevSlot, mTimer, RestoreFocus(), ToolBar::SetDocked(), and ToolBarConfiguration::UnspecifiedPosition.

Referenced by HandleEscapeKey(), and OnMouse().

Here is the call graph for this function:
Here is the caller graph for this function:

◆ Expose()

void ToolManager::Expose ( Identifier  type,
bool  show 
)

Definition at line 1066 of file ToolManager.cpp.

1067{
1068 ToolBar *t = mBars[type].get();
1069
1070 // Handle docked and floaters differently
1071 if( t->IsDocked() )
1072 {
1073 t->GetDock()->Expose( t->GetSection(), show );
1074 }
1075 else
1076 {
1077 t->Expose( show );
1078 }
1079}
bool IsDocked() const
Definition: ToolBar.cpp:433
Identifier GetSection()
Definition: ToolBar.cpp:400
virtual bool Expose(bool show=true)
Definition: ToolBar.cpp:459
void Expose(Identifier type, bool show)
Definition: ToolDock.cpp:858

References ToolBar::Expose(), ToolDock::Expose(), ToolBar::GetDock(), ToolBar::GetSection(), ToolBar::IsDocked(), and mBars.

Referenced by ReadConfig(), Reset(), and ShowHide().

Here is the call graph for this function:
Here is the caller graph for this function:

◆ FilterEvent()

int ToolManager::FilterEvent ( wxEvent &  event)
override

Definition at line 692 of file ToolManager.cpp.

693{
694 // Snoop the global event stream for changes of focused window. Remember
695 // the last one of our own that is not a grabber.
696
697 if (event.GetEventType() == wxEVT_KILL_FOCUS) {
698 auto &focusEvent = static_cast<wxFocusEvent&>(event);
699 auto window = focusEvent.GetWindow();
700 auto top = wxGetTopLevelParent(window);
701 if(auto toolFrame = dynamic_cast<ToolFrame*>(top))
702 top = toolFrame->GetParent();
703 // window is that which will GET the focus
704 if ( window &&
705 !dynamic_cast<Grabber*>( window ) &&
706 !dynamic_cast<ToolFrame*>( window ) &&
707 top == FindProjectFrame( mParent ) )
708 // Note this is a dangle-proof wxWindowRef:
709 mLastFocus = window;
710 }
711
712 return Event_Skip;
713}
wxFrame * FindProjectFrame(AudacityProject *project)
Get a pointer to the window associated with a project, or null if the given pointer is null,...
The widget to the left of a ToolBar that allows it to be dragged around to NEW positions.
Definition: Grabber.h:107
class ToolFrame
Definition: ToolManager.h:190
wxWindowRef mLastFocus
Definition: ToolManager.h:141

References FindProjectFrame(), mLastFocus, and mParent.

Here is the call graph for this function:

◆ Float()

ToolBar * ToolManager::Float ( ToolBar t,
wxPoint &  pos 
)
private

◆ ForEach()

template<typename F >
void ToolManager::ForEach ( F &&  fun)
inline

Visit bars, lexicographically by their textual ids.

Definition at line 103 of file ToolManager.h.

104 {
105 std::for_each(std::begin(mBars), std::end(mBars), [&fun](auto &pair){
106 fun(pair.second.get());
107 });
108 }
auto end(const Ptr< Type, BaseDeleter > &p)
Enables range-for.
Definition: PackedArray.h:159
auto begin(const Ptr< Type, BaseDeleter > &p)
Enables range-for.
Definition: PackedArray.h:150

References PackedArray::begin(), and PackedArray::end().

Referenced by CreateWindows(), ScreenshotCommand::kCaptureWhatStrings(), ScreenshotBigDialog::PopulateOrExchange(), ReadConfig(), RegenerateTooltips(), Reset(), and WriteConfig().

Here is the call graph for this function:
Here is the caller graph for this function:

◆ Get() [1/2]

ToolManager & ToolManager::Get ( AudacityProject project)
static

◆ Get() [2/2]

const ToolManager & ToolManager::Get ( const AudacityProject project)
static

Definition at line 344 of file ToolManager.cpp.

345{
346 return Get( const_cast< AudacityProject & >( project ) );
347}
The top-level handle to an Audacity project. It serves as a source of events that other objects can b...
Definition: Project.h:90
static ToolManager & Get(AudacityProject &project)

References Get(), and project.

Here is the call graph for this function:

◆ GetBotDock() [1/2]

ToolDock * ToolManager::GetBotDock ( )

Definition at line 1001 of file ToolManager.cpp.

1002{
1003 return mBotDock;
1004}

References mBotDock.

◆ GetBotDock() [2/2]

const ToolDock * ToolManager::GetBotDock ( ) const

Definition at line 1006 of file ToolManager.cpp.

1007{
1008 return mBotDock;
1009}

References mBotDock.

◆ GetToolBar()

ToolBar * ToolManager::GetToolBar ( const Identifier type) const

Definition at line 979 of file ToolManager.cpp.

980{
981 auto end = mBars.end(), iter = mBars.find(type);
982 return (iter == end) ? nullptr : iter->second.get();
983}

References PackedArray::end(), and mBars.

Referenced by ScreenshotCommand::CaptureToolbar(), IsDocked(), IsVisible(), OnGrabber(), ReadConfig(), Reset(), and ProjectAudioManager::Stop().

Here is the call graph for this function:
Here is the caller graph for this function:

◆ GetTopDock() [1/2]

ToolDock * ToolManager::GetTopDock ( )

Definition at line 988 of file ToolManager.cpp.

989{
990 return mTopDock;
991}

References mTopDock.

◆ GetTopDock() [2/2]

const ToolDock * ToolManager::GetTopDock ( ) const

Definition at line 993 of file ToolManager.cpp.

994{
995 return mTopDock;
996}

References mTopDock.

◆ HandleEscapeKey()

void ToolManager::HandleEscapeKey ( )
private

Definition at line 1459 of file ToolManager.cpp.

1460{
1461 if (mDragBar) {
1462 if(mPrevDock) {
1463 // Sheriff John Stone,
1464 // Why don't you leave me alone?
1465 // Well, I feel so break up
1466 // I want to go home.
1468 mPrevDock->Dock( mDragBar, true, mPrevSlot );
1469 Updated();
1470
1471 // Done with the floater
1473 mDragWindow->Destroy();
1474 mDragWindow = nullptr;
1475 mDragBar->Refresh(false);
1476 }
1477 else {
1478 // Floater remains, and returns to where it begain
1479 auto parent = mDragBar->GetParent();
1480 parent->SetPosition(mPrevPosition);
1481 mDragBar->SetDocked(NULL, false);
1482 }
1483
1484 DoneDragging();
1485 }
1486}
void RestoreConfiguration(ToolBarConfiguration &backup)
Definition: ToolDock.cpp:848
void Dock(ToolBar *bar, bool deflate, ToolBarConfiguration::Position ndx=ToolBarConfiguration::UnspecifiedPosition)
Definition: ToolDock.cpp:438
void ClearBar()
Definition: ToolManager.h:198
wxPoint mPrevPosition
Definition: ToolManager.h:170
void DoneDragging()

References ToolFrame::ClearBar(), ToolDock::Dock(), DoneDragging(), mDragBar, mDragWindow, mPrevConfiguration, mPrevDock, mPrevPosition, mPrevSlot, ToolDock::RestoreConfiguration(), ToolBar::SetDocked(), and Updated().

Referenced by OnGrabber().

Here is the call graph for this function:
Here is the caller graph for this function:

◆ IsDocked()

bool ToolManager::IsDocked ( Identifier  type) const

Definition at line 1025 of file ToolManager.cpp.

1026{
1027 if (auto pBar = GetToolBar(type))
1028 return pBar->IsDocked();
1029 return false;
1030}
ToolBar * GetToolBar(const Identifier &type) const

References GetToolBar().

Here is the call graph for this function:

◆ IsVisible()

bool ToolManager::IsVisible ( Identifier  type) const

Definition at line 1035 of file ToolManager.cpp.

1036{
1037 if (auto pBar = GetToolBar(type))
1038 return pBar->IsVisible();
1039 return false;
1040
1041#if 0
1042 // If toolbar is floating
1043 if( !t->IsDocked() )
1044 {
1045 // Must return state of floater window
1046 return t->GetParent()->IsShown();
1047 }
1048
1049 // Return state of docked toolbar
1050 return t->IsShown();
1051#endif
1052}

References GetToolBar().

Referenced by ScreenshotCommand::CaptureToolbar(), and ShowHide().

Here is the call graph for this function:
Here is the caller graph for this function:

◆ LayoutToolBars()

void ToolManager::LayoutToolBars ( )

Definition at line 1084 of file ToolManager.cpp.

1085{
1086 // Update the layout
1087 if (mTopDock)
1088 {
1090 }
1091
1092 if (mBotDock)
1093 {
1095 }
1096}
void LayoutToolBars()
Definition: ToolDock.cpp:687

References ToolDock::LayoutToolBars(), mBotDock, and mTopDock.

Referenced by InitProjectWindow(), and OnMouse().

Here is the call graph for this function:
Here is the caller graph for this function:

◆ ModifyAllProjectToolbarMenus()

void ToolManager::ModifyAllProjectToolbarMenus ( )
static

Definition at line 1533 of file ToolManager.cpp.

1534{
1535 for (auto pProject : AllProjects{}) {
1536 auto &project = *pProject;
1538 }
1539}
static void ModifyToolbarMenus(AudacityProject &project)

References ModifyToolbarMenus(), and project.

Referenced by anonymous_namespace{TrackMenus.cpp}::OnSyncLock(), anonymous_namespace{TransportMenus.cpp}::OnTogglePlayRecording(), anonymous_namespace{TransportMenus.cpp}::OnToggleSoundActivated(), anonymous_namespace{TransportMenus.cpp}::OnToggleSWPlaythrough(), anonymous_namespace{LabelMenus.cpp}::OnToggleTypeToCreateLabel(), and AdornedRulerPanel::TogglePinnedHead().

Here is the call graph for this function:
Here is the caller graph for this function:

◆ ModifyToolbarMenus()

void ToolManager::ModifyToolbarMenus ( AudacityProject project)
static

Definition at line 1542 of file ToolManager.cpp.

1543{
1544 // Refreshes can occur during shutdown and the toolmanager may already
1545 // be deleted, so protect against it.
1546 auto &toolManager = ToolManager::Get( project );
1547
1548 // Now, go through each toolbar, and call EnableDisableButtons()
1549 toolManager.ForEach([](auto bar){
1550 if (bar)
1551 bar->EnableDisableButtons();
1552 });
1553
1554 // These don't really belong here, but it's easier and especially so for
1555 // the Edit toolbar and the sync-lock menu item.
1556 bool active = SyncLockTracks.Read();
1558
1560}
BoolSetting SyncLockTracks
Definition: SyncLock.cpp:173
void UpdateCheckmarks(AudacityProject &project)
static CommandManager & Get(AudacityProject &project)
bool Read(T *pVar) const
overload of Read returning a boolean that is true if the value was previously defined *‍/
Definition: Prefs.h:205
void SetSyncLock(bool flag)
Definition: SyncLock.cpp:48
static SyncLockState & Get(AudacityProject &project)
Definition: SyncLock.cpp:26

References SyncLockState::Get(), CommandManager::Get(), Get(), project, Setting< T >::Read(), SyncLockState::SetSyncLock(), SyncLockTracks, and CommandManager::UpdateCheckmarks().

Referenced by ModifyAllProjectToolbarMenus(), anonymous_namespace{ExtraMenus.cpp}::OnFullScreen(), OnMenuUpdate(), OnResetToolBars(), and AttachedToolBarMenuItem::OnShowToolBar().

Here is the call graph for this function:
Here is the caller graph for this function:

◆ OnCaptureLost()

void ToolManager::OnCaptureLost ( wxMouseCaptureLostEvent &  event)
private

Definition at line 1288 of file ToolManager.cpp.

1289{
1290 // Can't do anything if we're not dragging. This also prevents
1291 // us from intercepting events that don't belong to us from the
1292 // parent since we're Connect()ed to a couple.
1293 if( !mDragWindow )
1294 {
1295 event.Skip();
1296 return;
1297 }
1298
1299 // Simulate button up
1300 wxMouseEvent e(wxEVT_LEFT_UP);
1301 e.SetEventObject(mParent);
1302 OnMouse(e);
1303}

References mDragWindow, mParent, and OnMouse().

Referenced by CreateWindows().

Here is the call graph for this function:
Here is the caller graph for this function:

◆ OnGrabber()

void ToolManager::OnGrabber ( GrabberEvent event)
private

Definition at line 1411 of file ToolManager.cpp.

1412{
1413 // No need to propagate any further
1414 event.Skip( false );
1415
1416 if(event.IsEscaping())
1417 return HandleEscapeKey();
1418
1419 // Remember which bar we're dragging
1420 mDragBar = GetToolBar(event.BarId());
1421
1422 // Remember state, in case of ESCape key later
1423 if (mDragBar->IsDocked()) {
1424 mPrevDock = dynamic_cast<ToolDock*>(mDragBar->GetParent());
1425 wxASSERT(mPrevDock);
1428 }
1429 else
1430 mPrevPosition = mDragBar->GetParent()->GetPosition();
1431
1432 // Calculate the drag offset
1433 wxPoint mp = event.GetPosition();
1434 mDragOffset = mp -
1435 mDragBar->GetParent()->ClientToScreen( mDragBar->GetPosition() ) +
1436 wxPoint( 1, 1 );
1437
1438 mClicked = true;
1439 if( mPrevDock )
1440 {
1441 mDragWindow = nullptr;
1442 }
1443 else
1444 {
1445 mDragWindow = (ToolFrame *) mDragBar->GetParent();
1446 }
1447
1448 // We want all mouse events from this point on
1449 auto &window = GetProjectFrame( *mParent );
1450 if( !window.HasCapture() )
1451 window.CaptureMouse();
1452
1453 // Start monitoring shift key changes
1454 mLastState = wxGetKeyState( WXK_SHIFT );
1455 mTimer.Start( 100 );
1456}
bool IsEscaping() const
Definition: Grabber.h:75
Identifier BarId() const
Definition: Grabber.h:77
Position Find(const ToolBar *bar) const
Definition: ToolDock.cpp:87
void WrapConfiguration(ToolBarConfiguration &backup)
Definition: ToolDock.cpp:841
bool mLastState
Definition: ToolManager.h:158
void HandleEscapeKey()
wxPoint mDragOffset
Definition: ToolManager.h:146

References GrabberEvent::BarId(), ToolBarConfiguration::Find(), ToolDock::GetConfiguration(), GetProjectFrame(), GetToolBar(), HandleEscapeKey(), ToolBar::IsDocked(), GrabberEvent::IsEscaping(), mClicked, mDragBar, mDragOffset, mDragWindow, mLastState, mParent, mPrevConfiguration, mPrevDock, mPrevPosition, mPrevSlot, mTimer, and ToolDock::WrapConfiguration().

Here is the call graph for this function:

◆ OnIndicatorCreate()

void ToolManager::OnIndicatorCreate ( wxWindowCreateEvent &  event)
private

Definition at line 1370 of file ToolManager.cpp.

1371{
1372#if defined(__WXGTK__)
1373 mIndicator->SetShape( *mCurrent );
1374#endif
1375 event.Skip();
1376}
wxRegion * mCurrent
Definition: ToolManager.h:155

References mCurrent, and mIndicator.

Referenced by ToolManager().

Here is the caller graph for this function:

◆ OnIndicatorPaint()

void ToolManager::OnIndicatorPaint ( wxPaintEvent &  event)
private

Definition at line 1353 of file ToolManager.cpp.

1354{
1355 // TODO: Better to use a bitmap than a triangular region.
1356 wxWindow *w = (wxWindow *)event.GetEventObject();
1357 wxPaintDC dc( w );
1358 // TODO: Better (faster) to use the existing spare brush.
1359 wxBrush brush( theTheme.Colour( clrTrackPanelText ) );
1360 dc.SetBackground( brush );
1361 dc.Clear();
1362}
THEME_API Theme theTheme
Definition: Theme.cpp:82
wxColour & Colour(int iIndex)

References ThemeBase::Colour(), and theTheme.

Referenced by ToolManager().

Here is the call graph for this function:
Here is the caller graph for this function:

◆ OnMenuUpdate()

void ToolManager::OnMenuUpdate ( struct MenuUpdateMessage  )
private

Definition at line 1305 of file ToolManager.cpp.

1306{
1308}

References ModifyToolbarMenus(), and mParent.

Referenced by CreateWindows().

Here is the call graph for this function:
Here is the caller graph for this function:

◆ OnMouse()

void ToolManager::OnMouse ( wxMouseEvent &  event)
private

Definition at line 1101 of file ToolManager.cpp.

1102{
1103 // Go ahead and set the event to propagate
1104 event.Skip();
1105
1106 // Can't do anything if we're not dragging. This also prevents
1107 // us from intercepting events that don't belong to us from the
1108 // parent since we're Connect()ed to a couple.
1109 if( !mClicked )
1110 {
1111 return;
1112 }
1113
1114#if defined(__WXMAC__)
1115 // Disable window animation
1116 wxSystemOptions::SetOption( wxMAC_WINDOW_PLAIN_TRANSITION, 1 );
1117#endif
1118
1119 // Retrieve the event position
1120 wxPoint pos =
1121 ( (wxWindow *)event.GetEventObject() )->ClientToScreen( event.GetPosition() ) - mDragOffset;
1122
1123
1124 if( !event.LeftIsDown() )
1125 {
1126 // Button was released...finish the drag
1127 // Transition the bar to a dock
1128 if (!mDidDrag) {
1129 if (mPrevDock)
1131 DoneDragging();
1132 return;
1133 }
1134 else if( mDragDock && !event.ShiftDown() )
1135 {
1136 // Trip over...everyone ashore that's going ashore...
1138 Updated();
1140
1141 // Done with the floater
1142 mDragWindow->Destroy();
1143 mDragWindow = nullptr;
1144 mDragBar->Refresh(false);
1145 }
1146 else
1147 {
1148 // Calling SetDocked() to force the grabber button to popup
1149 mDragBar->SetDocked( NULL, false );
1150 }
1151
1152 DoneDragging();
1153 }
1154 else if( event.Dragging() && pos != mLastPos )
1155 {
1156 if (!mDidDrag) {
1157 // Must set the bar afloat if it's currently docked
1158 mDidDrag = true;
1159 wxPoint mp = event.GetPosition();
1160 mp = GetProjectFrame( *mParent ).ClientToScreen(mp);
1161 if (!mDragWindow) {
1162 // We no longer have control
1163 if (mPrevDock)
1165 UndockBar(mp);
1166 // Rearrange the remaining toolbars before trying to re-insert this one.
1168 }
1169 }
1170
1171 // Make toolbar follow the mouse
1172 mDragWindow->Move( pos );
1173
1174 // Remember to prevent excessive movement
1175 mLastPos = pos;
1176
1177 // Calc the top dock hittest rectangle
1178 wxRect tr = mTopDock->GetRect();
1179 tr.SetBottom( tr.GetBottom() + 10 );
1180 tr.SetPosition( mTopDock->GetParent()->ClientToScreen( tr.GetPosition() ) );
1181
1182 // Calc the bottom dock hittest rectangle
1183 wxRect br = mBotDock->GetRect();
1184 br.SetTop( br.GetTop() - 10 );
1185 br.SetBottom( br.GetBottom() + 20 );
1186 br.SetPosition( mBotDock->GetParent()->ClientToScreen( br.GetPosition() ) );
1187
1188
1189 // Add half the bar height. We could use the actual bar height, but that would be confusing as a
1190 // bar removed at a place might not dock back there if just let go.
1191 // Also add 5 pixels in horizontal direction, so that a click without a move (or a very small move)
1192 // lands back where we started.
1193 pos += wxPoint( 5, 20 );
1194
1195
1196 // To find which dock, rather than test against pos, test against the whole dragger rect.
1197 // This means it is enough to overlap the dock to dock with it.
1198 wxRect barRect = mDragWindow->GetRect();
1199 ToolDock *dock = NULL;
1200 if( tr.Intersects( barRect ) )
1201 dock = mTopDock;
1202 else if( br.Intersects( barRect ) )
1203 dock = mBotDock;
1204
1205 // Looks like we have a winner...
1206 if( dock )
1207 {
1208 wxPoint p;
1209 wxRect r;
1210
1211 // Calculate where the bar would be placed
1212 mDragBefore = dock->PositionBar( mDragBar, pos, r );
1213
1214 // If different than the last time, the indicator must be moved
1215 if( r != mBarPos )
1216 {
1217 wxRect dr = dock->GetRect();
1218
1219 // Hide the indicator before changing the shape
1220 mIndicator->Hide();
1221
1222 // Decide which direction the arrow should point
1223 if( r.GetTop() >= dr.GetHeight() )
1224 {
1225 const auto &box = mDown->GetBox();
1226 p.x = dr.GetLeft() + ( dr.GetWidth() / 2 )
1227 - (box.GetWidth() / 2);
1228 p.y = dr.GetBottom() - box.GetHeight();
1229 mCurrent = mDown.get();
1230 }
1231 else
1232 {
1233 // r is the rectangle of the toolbar being dragged.
1234 // A tall undocked toolbar will become at most 2 tbs
1235 // high when docked, so the triangular drop indicator
1236 // needs to use that height, h, not the bar height
1237 // for calculating where to be drawn.
1238 const int tbs = toolbarSingle + toolbarGap;
1239 int h = wxMin(r.GetHeight(), 2*tbs-1);
1240 p.x = dr.GetLeft() + r.GetLeft();
1241 p.y = dr.GetTop() + r.GetTop() +
1242 ( ( h - mLeft->GetBox().GetHeight() ) / 2 );
1243 mCurrent = mLeft.get();
1244 }
1245
1246 // Change the shape while hidden and then show it if okay
1247 mIndicator->SetShape( *mCurrent );
1248 if( !event.ShiftDown() )
1249 {
1250 mIndicator->Show();
1251 mIndicator->Update();
1252 }
1253
1254 // Move it into position
1255 // LL: Do this after the Show() since KDE doesn't move the window
1256 // if it's not shown. (Do it outside if the previous IF as well)
1257 mIndicator->Move( dock->GetParent()->ClientToScreen( p ) );
1258
1259 // Remember for next go round
1260 mBarPos = r;
1261 }
1262 }
1263 else
1264 {
1265 // Hide the indicator if it's still shown
1266 if( mBarPos.x != -1 )
1267 {
1268 // Hide any
1269 mIndicator->Hide();
1270 mBarPos.x = -1;
1271 mBarPos.y = -1;
1272 }
1273 }
1274
1275 // Remember to which dock the drag bar belongs.
1276 mDragDock = dock;
1277 }
1278
1279#if defined(__WXMAC__)
1280 // Reinstate original transition
1281 wxSystemOptions::SetOption( wxMAC_WINDOW_PLAIN_TRANSITION, mTransition );
1282#endif
1283}
#define toolbarSingle
Definition: ToolBar.h:59
#define toolbarGap
Definition: ToolBar.h:64
void Remove(const ToolBar *bar)
Definition: ToolDock.cpp:224
ToolBarConfiguration::Position PositionBar(ToolBar *t, const wxPoint &pos, wxRect &rect)
Definition: ToolDock.cpp:744
void UndockBar(wxPoint mp)
void LayoutToolBars()
ToolBarConfiguration::Position mDragBefore
Definition: ToolManager.h:147

References ToolFrame::ClearBar(), ToolDock::Dock(), DoneDragging(), ToolDock::GetConfiguration(), GetProjectFrame(), LayoutToolBars(), mBarPos, mBotDock, mClicked, mCurrent, mDidDrag, mDown, mDragBar, mDragBefore, mDragDock, mDragOffset, mDragWindow, mIndicator, mLastPos, mLeft, mPrevConfiguration, mPrevDock, mTopDock, mTransition, ToolDock::PositionBar(), ToolBarConfiguration::Remove(), ToolDock::RestoreConfiguration(), ToolBar::SetDocked(), toolbarGap, toolbarSingle, UndockBar(), and Updated().

Referenced by CreateWindows(), and OnCaptureLost().

Here is the call graph for this function:
Here is the caller graph for this function:

◆ OnResetToolBars()

void ToolManager::OnResetToolBars ( const CommandContext context)
static

Definition at line 568 of file ToolManager.cpp.

569{
570 auto &project = context.project;
571 auto &toolManager = ToolManager::Get( project );
572
573 toolManager.Reset();
575}
AudacityProject & project

References Get(), ModifyToolbarMenus(), project, and CommandContext::project.

Referenced by anonymous_namespace{PluginMenus.cpp}::OnResetConfig(), and anonymous_namespace{ToolbarMenus.cpp}::ToolbarsMenu().

Here is the call graph for this function:
Here is the caller graph for this function:

◆ OnTimer()

void ToolManager::OnTimer ( wxTimerEvent &  event)
private

Definition at line 1313 of file ToolManager.cpp.

1314{
1315 // Go ahead and set the event to propagate
1316 event.Skip();
1317
1318 // Can't do anything if we're not dragging. This also prevents
1319 // us from intercepting events that don't belong to us from the
1320 // parent since we're Connect()ed to a couple.
1321 if( !mDragWindow )
1322 {
1323 return;
1324 }
1325
1326 bool state = wxGetKeyState( WXK_SHIFT );
1327 if( mLastState != state )
1328 {
1329 mLastState = state;
1330
1331#if defined(__WXMAC__)
1332 // Disable window animation
1333 wxSystemOptions::SetOption( wxMAC_WINDOW_PLAIN_TRANSITION, 1 );
1334#endif
1335
1336 mIndicator->Show( !state );
1337
1338#if defined(__WXMAC__)
1339 // Disable window animation
1340 wxSystemOptions::SetOption( wxMAC_WINDOW_PLAIN_TRANSITION, mTransition );
1341#endif
1342 }
1343
1344 return;
1345}

References mDragWindow, mIndicator, mLastState, and mTransition.

◆ operator=()

ToolManager & ToolManager::operator= ( const ToolManager )
delete

◆ ReadConfig()

void ToolManager::ReadConfig ( )
private

Definition at line 718 of file ToolManager.cpp.

719{
720 std::vector<Identifier> unordered[ DockCount ];
721 std::vector<ToolBar*> dockedAndHidden;
722 std::map<Identifier, bool> show;
723 std::map<Identifier, int> width;
724 std::map<Identifier, int> height;
725 int x, y;
726 int dock;
727 bool someFound { false };
728
729#if defined(__WXMAC__)
730 // Disable window animation
731 wxSystemOptions::SetOption( wxMAC_WINDOW_PLAIN_TRANSITION, 1 );
732#endif
733
734 // Change to the bar root
735 auto toolbarsGroup = gPrefs->BeginGroup("/GUI/ToolBars");
736
737 ToolBarConfiguration::Legacy topLegacy, botLegacy;
738
739 int vMajor, vMinor, vMicro;
740 GetPreferencesVersion(vMajor, vMinor, vMicro);
741 bool useLegacyDock = false;
742 // note that vMajor, vMinor, and vMicro will all be zero if either it's a new audacity.cfg file
743 // or the version is less than 1.3.13 (when there were no version keys according to the comments in
744 // InitPreferences()). So for new audacity.cfg
745 // file useLegacyDock will be true, but this doesn't matter as there are no Dock or DockV2 keys in the file yet.
746 if (vMajor <= 1 ||
747 (vMajor == 2 && (vMinor <= 1 || (vMinor == 2 && vMicro <= 1)))) // version <= 2.2.1
748 useLegacyDock = true;
749
750
751 // Load and apply settings for each bar
752 ForEach([&](ToolBar *bar){
753 //wxPoint Center = mParent->GetPosition() + (mParent->GetSize() * 0.33);
754 //wxPoint Center(
755 // wxSystemSettings::GetMetric( wxSYS_SCREEN_X ) /2 ,
756 // wxSystemSettings::GetMetric( wxSYS_SCREEN_Y ) /2 );
757
758 // Change to the bar subkey
759 auto ndx = bar->GetSection();
760 auto barGroup = gPrefs->BeginGroup(ndx.GET());
761
762 const bool bShownByDefault = bar->ShownByDefault();
763 const int defaultDock = bar->DefaultDockID();
764
765 // Read in all the settings
766
767 if (useLegacyDock)
768 gPrefs->Read( wxT("Dock"), &dock, -1); // legacy version of DockV2
769 else
770 gPrefs->Read( wxT("DockV2"), &dock, -1);
771
772 const bool found = (dock != -1);
773 if (found)
774 someFound = true;
775 if (!found)
776 dock = defaultDock;
777
778 ToolDock *d;
780 switch(dock)
781 {
782 case TopDockID: d = mTopDock; pLegacy = &topLegacy; break;
783 case BotDockID: d = mBotDock; pLegacy = &botLegacy; break;
784 default: d = nullptr; pLegacy = nullptr; break;
785 }
786
787 bool ordered = ToolBarConfiguration::Read(
788 d ? &d->GetConfiguration() : nullptr,
789 pLegacy,
790 bar, show[ ndx ], bShownByDefault)
791 && found;
792
793 gPrefs->Read( wxT("X"), &x, -1 );
794 gPrefs->Read( wxT("Y"), &y, -1 );
795 gPrefs->Read( wxT("W"), &width[ ndx ], -1 );
796 gPrefs->Read( wxT("H"), &height[ ndx ], -1 );
797
798 bar->SetVisible( show[ ndx ] );
799
800 // Docked or floating?
801 if( dock )
802 {
803 // Default to top dock if the ID isn't valid
804 if( dock < NoDockID || dock > DockCount ) {
805 dock = TopDockID;
806 }
807
808 // Create the bar with the correct parent
809 if( dock == TopDockID )
810 {
811 bar->Create( mTopDock );
812 }
813 else
814 {
815 bar->Create( mBotDock );
816 }
817
818 // Set the width and height
819 if( width[ ndx ] != -1 && height[ ndx ] != -1 )
820 {
821 wxSize sz( width[ ndx ], height[ ndx ] );
822 bar->SetSize( sz );
823 bar->ResizingDone();
824 }
825
826 // Set the width
827 if( width[ ndx ] >= bar->GetSize().x )
828 {
829 wxSize sz( width[ ndx ], bar->GetSize().y );
830 bar->SetSize( sz );
831 bar->Layout();
832 }
833
834 // make a note of docked and hidden toolbars
835 if (!show[ndx])
836 dockedAndHidden.push_back(bar);
837
838 if (!ordered)
839 {
840 // These must go at the end
841 unordered[ dock - 1 ].push_back( ndx );
842 }
843 }
844 else
845 {
846 // Create the bar (with the top dock being temporary parent)
847 bar->Create( mTopDock );
848
849 // Construct a NEW floater
850 wxASSERT(mParent);
851 ToolFrame *f = safenew ToolFrame( mParent, this, bar, wxPoint( x, y ) );
852
853 // Set the width and height
854 if( width[ ndx ] != -1 && height[ ndx ] != -1 )
855 {
856 wxSize sz( width[ ndx ], height[ ndx ] );
857 f->SetSizeHints( sz );
858 f->SetSize( sz );
859 f->Layout();
860 if( (x!=-1) && (y!=-1) )
861 bar->SetPositioned();
862 }
863
864 // Required on Linux Xfce
865 wxSize msz(width[ndx],height[ndx]-1);
866 bar->GetParent()->SetMinSize(msz);
867
868 // Inform toolbar of change
869 bar->SetDocked( NULL, false );
870
871 // Show or hide it
872 Expose( bar->GetSection(), show[ ndx ] );
873 }
874 });
875
876 mTopDock->GetConfiguration().PostRead(topLegacy);
877 mBotDock->GetConfiguration().PostRead(botLegacy);
878
879 // Add all toolbars to their target dock
880 for( dock = 0; dock < DockCount; dock++ )
881 {
882 ToolDock *d = ( dock + 1 == TopDockID ? mTopDock : mBotDock );
883
884 d->LoadConfig();
885
886 // Add all unordered toolbars
887 for( int ord = 0; ord < (int) unordered[ dock ].size(); ord++ )
888 {
889 ToolBar *t = mBars[unordered[dock][ord]].get();
890
891 // Dock it
892 d->Dock( t, false );
893
894 // Show or hide the bar
895 Expose( t->GetSection(), show[ t->GetSection() ] );
896 }
897 }
898
899 // hidden docked toolbars
900 for (auto bar : dockedAndHidden) {
901 bar->SetVisible(false );
902 bar->GetDock()->Dock(bar, false);
903 bar->Expose(false);
904 }
905
906 toolbarsGroup.Reset();
907
908#if defined(__WXMAC__)
909 // Reinstate original transition
910 wxSystemOptions::SetOption( wxMAC_WINDOW_PLAIN_TRANSITION, mTransition );
911#endif
912
913 // Setup the neighbors according to the
914 // default config
915
916 for (const auto& entry : DefaultConfigTable)
917 {
918 const auto &ndx = entry.barID;
919 const auto bar = GetToolBar(ndx);
920 bar->SetPreferredNeighbors(entry.rightOf, entry.below);
921 }
922
923 if (!someFound)
924 Reset();
925}
wxT("CloseDown"))
audacity::BasicSettings * gPrefs
Definition: Prefs.cpp:68
void GetPreferencesVersion(int &vMajor, int &vMinor, int &vMicro)
Definition: Prefs.cpp:210
static ProjectFileIORegistry::AttributeWriterEntry entry
@ DockCount
Definition: ToolDock.h:45
static struct DefaultConfigEntry DefaultConfigTable[]
static bool Read(ToolBarConfiguration *pConfiguration, Legacy *pLegacy, ToolBar *bar, bool &visible, bool defaultVisible)
Definition: ToolDock.cpp:281
void PostRead(Legacy &legacy)
Definition: ToolDock.cpp:334
void SetVisible(bool bVisible)
Definition: ToolBar.cpp:446
virtual void ResizingDone()
Definition: ToolBar.h:197
void SetPositioned()
Definition: ToolBar.h:140
void SetPreferredNeighbors(Identifier left, Identifier top={})
Definition: ToolBar.cpp:652
virtual bool ShownByDefault() const
Whether the toolbar should be shown by default. Default implementation returns true.
Definition: ToolBar.cpp:365
virtual void Create(wxWindow *parent)
Definition: ToolBar.cpp:492
virtual DockID DefaultDockID() const
Which dock the toolbar defaults into. Default implementation chooses the top dock.
Definition: ToolBar.cpp:375
void LoadConfig()
Definition: ToolDock.cpp:466
void Expose(Identifier type, bool show)
GroupScope BeginGroup(const wxString &prefix)
Appends a prefix to the current group or sets a new absolute path. Group that was set as current befo...
virtual bool Read(const wxString &key, bool *value) const =0

References audacity::BasicSettings::BeginGroup(), BotDockID, ToolBar::Create(), DefaultConfigTable, ToolBar::DefaultDockID(), ToolDock::Dock(), DockCount, entry, ToolBar::Expose(), Expose(), ForEach(), ToolDock::GetConfiguration(), ToolBar::GetDock(), GetPreferencesVersion(), ToolBar::GetSection(), GetToolBar(), gPrefs, ToolDock::LoadConfig(), mBars, mBotDock, mParent, mTopDock, mTransition, ToolBarConfiguration::PostRead(), audacity::BasicSettings::Read(), ToolBarConfiguration::Read(), Reset(), ToolBar::ResizingDone(), safenew, ToolBar::SetDocked(), ToolBar::SetPositioned(), ToolBar::SetPreferredNeighbors(), ToolBar::SetVisible(), ToolBar::ShownByDefault(), size, TopDockID, and wxT().

Referenced by CreateWindows().

Here is the call graph for this function:
Here is the caller graph for this function:

◆ RegenerateTooltips()

void ToolManager::RegenerateTooltips ( )

Definition at line 684 of file ToolManager.cpp.

685{
686 ForEach([](auto bar){
687 if (bar)
688 bar->RegenerateTooltips();
689 });
690}

References ForEach().

Referenced by ProjectManager::New().

Here is the call graph for this function:
Here is the caller graph for this function:

◆ Reset()

void ToolManager::Reset ( )

Definition at line 578 of file ToolManager.cpp.

579{
580 // Disconnect all docked bars
581 for ( const auto &entry : DefaultConfigTable )
582 {
583 const auto &ndx = entry.barID;
584 ToolBar *bar = GetToolBar(ndx);
585 if (!bar)
586 continue;
587
589 (entry.rightOf == Identifier{}) ? nullptr : GetToolBar(entry.rightOf),
590 (entry.below == Identifier{}) ? nullptr : GetToolBar(entry.below)
591 };
592
593 bar->SetSize( 20,20 );
594
595 wxWindow *floater;
596 ToolDock *dock;
597 bool expose = true;
598
599 // Disconnect the bar
600 if( bar->IsDocked() )
601 {
602 bar->GetDock()->Undock( bar );
603 floater = NULL;
604 }
605 else
606 {
607 floater = bar->GetParent();
608 }
609
610 // Decide which dock.
611 dock = (bar->DefaultDockID() == ToolBar::TopDockID)
612 ? mTopDock : mBotDock;
613
614 // PRL: Destroy the tool frame before recreating buttons.
615 // This fixes some subtle sizing problems on macOs.
616 bar->Reparent( dock );
617 //OK (and good) to DELETE floater, as bar is no longer in it.
618 if( floater )
619 floater->Destroy();
620
621 // Recreate bar buttons (and resize it)
622 bar->SetToDefaultSize();
623 bar->ReCreateButtons();
625
626#if 0
627 if( bar->IsResizable() )
628 {
629 bar->SetSize(bar->GetBestFittingSize());
630 }
631#endif
632
633 // Hide some bars.
634 expose = bar->ShownByDefault() || bar->HideAfterReset();
635
636 // Next condition will always (?) be true, as the reset configuration is
637 // with no floating toolbars.
638 if( dock != NULL )
639 {
640 // when we dock, we reparent, so bar is no longer a child of floater.
641 dock->Dock( bar, false, position );
642 Expose( bar->GetSection(), expose );
643 }
644 else
645 {
646 // The (tool)bar has a dragger window round it, the floater.
647 // in turn floater will have mParent (the entire App) as its
648 // parent.
649
650 // Maybe construct a NEW floater
651 // this happens if we have just been bounced out of a dock.
652 if( floater == NULL ) {
653 wxASSERT(mParent);
654 floater = safenew ToolFrame( mParent, this, bar, wxPoint(-1,-1) );
655 bar->Reparent( floater );
656 }
657
658 // This bar is undocked and invisible.
659 // We are doing a reset toolbars, so even the invisible undocked bars should
660 // be moved somewhere sensible. Put bar near center of window.
661 // If there were multiple hidden toobars the * 10 adjustment means
662 // they won't overlap too much.
663 floater->CentreOnParent( );
664 const auto index = bar->GetIndex();
665 floater->Move(
666 floater->GetPosition() + wxSize{ index * 10 - 200, index * 10 });
667 bar->SetDocked( NULL, false );
668 Expose( bar->GetSection(), false );
669 }
670 }
671
672 ForEach([this](auto bar){
673 if (bar && bar->HideAfterReset())
674 Expose(bar->GetSection(), false);
675 });
676 // TODO:??
677 // If audio was playing, we stopped the VU meters,
678 // It would be nice to show them again, but hardly essential as
679 // they will show up again on the next play.
680 // SetVUMeters(AudacityProject *p);
681 Updated();
682}
An explicitly nonlocalized string, not meant for the user to see.
Definition: Identifier.h:22
virtual void EnableDisableButtons()=0
@ TopDockID
Definition: ToolBar.h:93
virtual void ReCreateButtons()
Definition: ToolBar.cpp:533
bool IsResizable() const
Definition: ToolBar.cpp:425
int GetIndex() const
Get a value used for computing cascading positions of undocked bars.
Definition: ToolBar.h:112
virtual void SetToDefaultSize()
Definition: ToolBar.cpp:513
virtual bool HideAfterReset() const
Default implementation returns false.
Definition: ToolBar.cpp:370
void Undock(ToolBar *bar)
Definition: ToolDock.cpp:426

References DefaultConfigTable, ToolBar::DefaultDockID(), ToolDock::Dock(), ToolBar::EnableDisableButtons(), entry, Expose(), ForEach(), ToolBar::GetDock(), ToolBar::GetIndex(), ToolBar::GetSection(), GetToolBar(), ToolBar::HideAfterReset(), ToolBar::IsDocked(), ToolBar::IsResizable(), mBotDock, mParent, mTopDock, ToolBar::ReCreateButtons(), safenew, ToolBar::SetDocked(), ToolBar::SetToDefaultSize(), ToolBar::ShownByDefault(), ToolBar::TopDockID, ToolDock::Undock(), and Updated().

Referenced by ReadConfig().

Here is the call graph for this function:
Here is the caller graph for this function:

◆ RestoreFocus()

bool ToolManager::RestoreFocus ( )

Definition at line 1521 of file ToolManager.cpp.

1522{
1523 if (mLastFocus) {
1524 auto temp1 = AButton::TemporarilyAllowFocus();
1525 auto temp2 = ASlider::TemporarilyAllowFocus();
1527 mLastFocus->SetFocus();
1528 return true;
1529 }
1530 return false;
1531}
static TempAllowFocus TemporarilyAllowFocus()
Definition: AButton.cpp:658
static TempAllowFocus TemporarilyAllowFocus()
Definition: ASlider.cpp:1894
static TempAllowFocus TemporarilyAllowFocus()

References mLastFocus, AButton::TemporarilyAllowFocus(), ASlider::TemporarilyAllowFocus(), and MeterPanelBase::TemporarilyAllowFocus().

Referenced by DoneDragging().

Here is the call graph for this function:
Here is the caller graph for this function:

◆ ShowHide()

void ToolManager::ShowHide ( Identifier  type)

Definition at line 1057 of file ToolManager.cpp.

1058{
1059 Expose( type, !mBars[type]->IsVisible() );
1060 Updated();
1061}
bool IsVisible(Identifier type) const

References Expose(), IsVisible(), mBars, and Updated().

Referenced by ScreenshotCommand::CaptureToolbar().

Here is the call graph for this function:
Here is the caller graph for this function:

◆ UndockBar()

void ToolManager::UndockBar ( wxPoint  mp)
private

Definition at line 1378 of file ToolManager.cpp.

1379{
1380#if defined(__WXMAC__)
1381 // Disable window animation
1382 wxSystemOptions::SetOption( wxMAC_WINDOW_PLAIN_TRANSITION, 1 );
1383#endif
1384
1385 // Adjust the starting position
1386 mp -= mDragOffset;
1387
1388 // Inform toolbar of change
1389 mDragBar->SetDocked( NULL, true );
1391
1392 // Construct a NEW floater
1393 wxASSERT(mParent);
1395 mDragWindow->SetLayoutDirection(wxLayout_LeftToRight);
1396 // Make sure the ferry is visible
1397 mDragWindow->Show();
1398
1399 // Notify parent of change
1400 Updated();
1401
1402#if defined(__WXMAC__)
1403 // Reinstate original transition
1404 wxSystemOptions::SetOption( wxMAC_WINDOW_PLAIN_TRANSITION, mTransition );
1405#endif
1406}

References mDragBar, mDragOffset, mDragWindow, mParent, mTransition, safenew, ToolBar::SetDocked(), ToolBar::SetPositioned(), and Updated().

Referenced by OnMouse().

Here is the call graph for this function:
Here is the caller graph for this function:

◆ Updated()

void ToolManager::Updated ( )
private

Definition at line 1015 of file ToolManager.cpp.

1016{
1017 // Queue an update event
1018 wxCommandEvent e( EVT_TOOLBAR_UPDATED );
1019 GetProjectFrame( *mParent ).GetEventHandler()->AddPendingEvent( e );
1020}

References GetProjectFrame().

Referenced by HandleEscapeKey(), OnMouse(), Reset(), ShowHide(), and UndockBar().

Here is the call graph for this function:
Here is the caller graph for this function:

◆ WriteConfig()

void ToolManager::WriteConfig ( )
private

Definition at line 930 of file ToolManager.cpp.

931{
932 if( !gPrefs )
933 {
934 return;
935 }
936
937 auto toolbarsGroup = gPrefs->BeginGroup("/GUI/ToolBars");
938
939 // Save state of each bar
940 ForEach([this](ToolBar *bar){
941 // Change to the bar subkey
942 auto sectionGroup = gPrefs->BeginGroup(bar->GetSection().GET());
943
944 // Search both docks for toolbar order
945 bool to = mTopDock->GetConfiguration().Contains( bar );
946 bool bo = mBotDock->GetConfiguration().Contains( bar );
947
948 // Save
949 // Note that DockV2 was introduced in 2.2.2 to fix bug #1554. Dock is retained so that
950 // the toolbar layout is not changed when opening a version before 2.2.2, and in particular
951 // its value is compatible with versions 2.1.3 to 2.2.1 which have this bug.
952 ToolDock* dock = bar->GetDock(); // dock for both shown and hidden toolbars
953 gPrefs->Write( wxT("DockV2"), static_cast<int>(dock == mTopDock ? TopDockID : dock == mBotDock ? BotDockID : NoDockID ));
954
955 gPrefs->Write( wxT("Dock"), static_cast<int>( to ? TopDockID : bo ? BotDockID : NoDockID));
956
957 dock = to ? mTopDock : bo ? mBotDock : nullptr; // dock for shown toolbars
959 (dock ? &dock->GetConfiguration() : nullptr, bar);
960
961 wxPoint pos( -1, -1 );
962 wxSize sz = bar->GetSize();
963 if( !bar->IsDocked() && bar->IsPositioned() )
964 {
965 pos = bar->GetParent()->GetPosition();
966 sz = bar->GetParent()->GetSize();
967 }
968 gPrefs->Write( wxT("X"), pos.x );
969 gPrefs->Write( wxT("Y"), pos.y );
970 gPrefs->Write( wxT("W"), sz.x );
971 gPrefs->Write( wxT("H"), sz.y );
972 });
973 gPrefs->Flush();
974}
@ NoDockID
Definition: ToolDock.h:42
const wxString & GET() const
Explicit conversion to wxString, meant to be ugly-looking and demanding of a comment why it's correct...
Definition: Identifier.h:66
bool Contains(const ToolBar *bar) const
Definition: ToolDock.h:235
static void Write(const ToolBarConfiguration *pConfiguration, const ToolBar *bar)
Definition: ToolDock.cpp:355
bool IsPositioned()
Definition: ToolBar.h:138
virtual bool Flush() noexcept=0
virtual bool Write(const wxString &key, bool value)=0

References audacity::BasicSettings::BeginGroup(), BotDockID, ToolBarConfiguration::Contains(), audacity::BasicSettings::Flush(), ForEach(), Identifier::GET(), ToolDock::GetConfiguration(), ToolBar::GetDock(), ToolBar::GetSection(), gPrefs, ToolBar::IsDocked(), ToolBar::IsPositioned(), mBotDock, mTopDock, NoDockID, TopDockID, ToolBarConfiguration::Write(), audacity::BasicSettings::Write(), and wxT().

Referenced by Destroy().

Here is the call graph for this function:
Here is the caller graph for this function:

Member Data Documentation

◆ mBarPos

wxRect ToolManager::mBarPos
private

Definition at line 150 of file ToolManager.h.

Referenced by DoneDragging(), OnMouse(), and ToolManager().

◆ mBars

std::map<Identifier, ToolBar::Holder> ToolManager::mBars
private

map not unordered_map, for the promise made by ForEach

Definition at line 168 of file ToolManager.h.

Referenced by CreateWindows(), Destroy(), Expose(), GetToolBar(), ReadConfig(), and ShowHide().

◆ mBotDock

ToolDock* ToolManager::mBotDock {}
private

◆ mClicked

bool ToolManager::mClicked {}
private

Definition at line 176 of file ToolManager.h.

Referenced by DoneDragging(), OnGrabber(), and OnMouse().

◆ mCurrent

wxRegion* ToolManager::mCurrent
private

Definition at line 155 of file ToolManager.h.

Referenced by OnIndicatorCreate(), and OnMouse().

◆ mDidDrag

bool ToolManager::mDidDrag {}
private

Definition at line 175 of file ToolManager.h.

Referenced by DoneDragging(), and OnMouse().

◆ mDown

std::unique_ptr<wxRegion> ToolManager::mDown
private

Definition at line 154 of file ToolManager.h.

Referenced by OnMouse(), and ToolManager().

◆ mDragBar

ToolBar* ToolManager::mDragBar {}
private

Definition at line 145 of file ToolManager.h.

Referenced by DoneDragging(), HandleEscapeKey(), OnGrabber(), OnMouse(), ToolManager(), and UndockBar().

◆ mDragBefore

ToolBarConfiguration::Position ToolManager::mDragBefore {}
private

Definition at line 147 of file ToolManager.h.

Referenced by OnMouse().

◆ mDragDock

ToolDock* ToolManager::mDragDock
private

Definition at line 144 of file ToolManager.h.

Referenced by DoneDragging(), OnMouse(), and ToolManager().

◆ mDragOffset

wxPoint ToolManager::mDragOffset
private

Definition at line 146 of file ToolManager.h.

Referenced by OnGrabber(), OnMouse(), and UndockBar().

◆ mDragWindow

ToolFrame* ToolManager::mDragWindow
private

◆ mIndicator

FramePtr ToolManager::mIndicator
private

Definition at line 153 of file ToolManager.h.

Referenced by Destroy(), DoneDragging(), OnIndicatorCreate(), OnMouse(), OnTimer(), and ToolManager().

◆ mLastFocus

wxWindowRef ToolManager::mLastFocus {}
private

Definition at line 141 of file ToolManager.h.

Referenced by FilterEvent(), and RestoreFocus().

◆ mLastPos

wxPoint ToolManager::mLastPos
private

Definition at line 149 of file ToolManager.h.

Referenced by DoneDragging(), OnMouse(), and ToolManager().

◆ mLastState

bool ToolManager::mLastState
private

Definition at line 158 of file ToolManager.h.

Referenced by OnGrabber(), and OnTimer().

◆ mLeft

std::unique_ptr<wxRegion> ToolManager::mLeft
private

Definition at line 154 of file ToolManager.h.

Referenced by OnMouse(), and ToolManager().

◆ mMenuManagerSubscription

Observer::Subscription ToolManager::mMenuManagerSubscription
private

Definition at line 139 of file ToolManager.h.

Referenced by CreateWindows().

◆ mParent

AudacityProject* ToolManager::mParent
private

◆ mPrevConfiguration

ToolBarConfiguration ToolManager::mPrevConfiguration
private

Definition at line 174 of file ToolManager.h.

Referenced by DoneDragging(), HandleEscapeKey(), OnGrabber(), and OnMouse().

◆ mPrevDock

ToolDock* ToolManager::mPrevDock {}
private

Definition at line 171 of file ToolManager.h.

Referenced by DoneDragging(), HandleEscapeKey(), OnGrabber(), and OnMouse().

◆ mPrevPosition

wxPoint ToolManager::mPrevPosition {}
private

Definition at line 170 of file ToolManager.h.

Referenced by HandleEscapeKey(), and OnGrabber().

◆ mPrevSlot

Definition at line 172 of file ToolManager.h.

Referenced by DoneDragging(), HandleEscapeKey(), and OnGrabber().

◆ mTimer

wxTimer ToolManager::mTimer
private

Definition at line 157 of file ToolManager.h.

Referenced by CreateWindows(), DoneDragging(), and OnGrabber().

◆ mTopDock

ToolDock* ToolManager::mTopDock {}
private

◆ mTransition

bool ToolManager::mTransition
private

Definition at line 161 of file ToolManager.h.

Referenced by OnMouse(), OnTimer(), ReadConfig(), ToolManager(), and UndockBar().


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