Audacity  3.0.3
Public Member Functions | Static Public Member Functions | Public Attributes | Private Member Functions | Private Attributes | List of all members
MenuManager Class Referencefinal

MenuManager handles updates to menu state. More...

#include <Menus.h>

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

Public Member Functions

 MenuManager (AudacityProject &project)
 
 MenuManager (const MenuManager &) PROHIBITED
 
MenuManageroperator= (const MenuManager &) PROHIBITED
 
 ~MenuManager ()
 
void UpdateMenus (bool checkActive=true)
 
CommandFlag GetUpdateFlags (bool checkActive=false) const
 
void UpdatePrefs () override
 
bool ReportIfActionNotAllowed (const TranslatableString &Name, CommandFlag &flags, CommandFlag flagsRqd)
 
bool TryToMakeActionAllowed (CommandFlag &flags, CommandFlag flagsRqd)
 
- Public Member Functions inherited from MenuCreator
 MenuCreator ()
 
 ~MenuCreator ()
 
void CreateMenusAndCommands (AudacityProject &project)
 
void RebuildMenuBar (AudacityProject &project)
 
- Public Member Functions inherited from ClientData::Base
virtual ~Base ()
 

Static Public Member Functions

static MenuManagerGet (AudacityProject &project)
 
static const MenuManagerGet (const AudacityProject &project)
 
static void Visit (ToolbarMenuVisitor &visitor)
 
static void ModifyUndoMenuItems (AudacityProject &project)
 
static void ModifyToolbarMenus (AudacityProject &project)
 
static void ModifyAllProjectToolbarMenus ()
 
- Static Public Member Functions inherited from MenuCreator
static void RebuildAllMenuBars ()
 

Public Attributes

int mWhatIfNoSelection
 
bool mStopIfWasPaused
 
- Public Attributes inherited from MenuCreator
CommandFlag mLastFlags
 
PluginID mLastGenerator {}
 
PluginID mLastEffect {}
 
PluginID mLastAnalyzer {}
 
int mLastAnalyzerRegistration
 
int mLastAnalyzerRegisteredId
 
PluginID mLastTool {}
 
int mLastToolRegistration
 
int mLastToolRegisteredId
 
unsigned mRepeatGeneratorFlags
 
unsigned mRepeatEffectFlags
 
unsigned mRepeatAnalyzerFlags
 
unsigned mRepeatToolFlags
 

Private Member Functions

void TellUserWhyDisallowed (const TranslatableString &Name, CommandFlag flagsGot, CommandFlag flagsRequired)
 
void OnUndoRedo (wxCommandEvent &evt)
 
- Private Member Functions inherited from PrefsListener
 PrefsListener ()
 
virtual ~PrefsListener ()
 
virtual void UpdateSelectedPrefs (int id)
 

Private Attributes

AudacityProjectmProject
 

Additional Inherited Members

- Public Types inherited from MenuCreator
enum  { repeattypenone = 0, repeattypeplugin = 1, repeattypeunique = 2, repeattypeapplymacro = 3 }
 
- Static Private Member Functions inherited from PrefsListener
static void Broadcast (int id=0)
 Call this static function to notify all PrefsListener objects. More...
 

Detailed Description

MenuManager handles updates to menu state.

Definition at line 73 of file Menus.h.

Constructor & Destructor Documentation

◆ MenuManager() [1/2]

MenuManager::MenuManager ( AudacityProject project)
explicit

Definition at line 80 of file Menus.cpp.

81  : mProject{ project }
82 {
83  UpdatePrefs();
84  mProject.Bind( EVT_UNDO_OR_REDO, &MenuManager::OnUndoRedo, this );
85  mProject.Bind( EVT_UNDO_RESET, &MenuManager::OnUndoRedo, this );
86  mProject.Bind( EVT_UNDO_PUSHED, &MenuManager::OnUndoRedo, this );
87  mProject.Bind( EVT_UNDO_RENAMED, &MenuManager::OnUndoRedo, this );
88 }

◆ MenuManager() [2/2]

MenuManager::MenuManager ( const MenuManager )

◆ ~MenuManager()

MenuManager::~MenuManager ( )

Definition at line 90 of file Menus.cpp.

91 {
92  mProject.Unbind( EVT_UNDO_OR_REDO, &MenuManager::OnUndoRedo, this );
93  mProject.Unbind( EVT_UNDO_RESET, &MenuManager::OnUndoRedo, this );
94  mProject.Unbind( EVT_UNDO_PUSHED, &MenuManager::OnUndoRedo, this );
95 }

References mProject, and OnUndoRedo().

Here is the call graph for this function:

Member Function Documentation

◆ Get() [1/2]

MenuManager & MenuManager::Get ( AudacityProject project)
static

Definition at line 70 of file Menus.cpp.

71 {
72  return project.AttachedObjects::Get< MenuManager >( key );
73 }

References key.

Referenced by anonymous_namespace{PluginMenus.cpp}::AnalyzeMenu(), MacroCommands::ApplyCommandInBatchMode(), CommonTrackPanelCell::DoContextMenu(), EffectUI::DoEffect(), ProjectAudioManager::DoRecord(), DoReloadPreferences(), anonymous_namespace{PluginMenus.cpp}::EffectMenu(), CommandManager::FilterKeyEvent(), ProjectWindow::FixScrollbars(), anonymous_namespace{PluginMenus.cpp}::GenerateMenu(), Get(), CommandManager::HandleCommandEntry(), anonymous_namespace{PluginMenus.cpp}::HasLastAnalyzerFlag(), anonymous_namespace{PluginMenus.cpp}::HasLastEffectFlag(), anonymous_namespace{PluginMenus.cpp}::HasLastGeneratorFlag(), anonymous_namespace{PluginMenus.cpp}::HasLastToolFlag(), ModifyAllProjectToolbarMenus(), ProjectManager::New(), EffectUIHost::OnApply(), PluginActions::Handler::OnApplyMacroDirectlyByName(), EditToolBar::OnButton(), ExtraActions::Handler::OnFullScreen(), ProjectWindow::OnMenu(), EditActions::Handler::OnPreferences(), PluginActions::Handler::OnRepeatLastAnalyzer(), PluginActions::Handler::OnRepeatLastEffect(), PluginActions::Handler::OnRepeatLastGenerator(), PluginActions::Handler::OnRepeatLastTool(), PluginActions::Handler::OnResetConfig(), ToolManager::OnResetToolBars(), AttachedToolBarMenuItem::OnShowToolBar(), ProjectWindow::OnUpdateUI(), MenuCreator::RebuildAllMenuBars(), CommandManager::RegisterLastAnalyzer(), CommandManager::RegisterLastTool(), SelectUtilities::SelectAllIfNone(), SelectUtilities::SelectAllIfNoneAndAllowed(), anonymous_namespace{PluginMenus.cpp}::ToolsMenu(), and MacrosWindow::UpdateMenus().

Here is the caller graph for this function:

◆ Get() [2/2]

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

Definition at line 75 of file Menus.cpp.

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

References Get().

Here is the call graph for this function:

◆ GetUpdateFlags()

CommandFlag MenuManager::GetUpdateFlags ( bool  checkActive = false) const

Definition at line 545 of file Menus.cpp.

546 {
547  // This method determines all of the flags that determine whether
548  // certain menu items and commands should be enabled or disabled,
549  // and returns them in a bitfield. Note that if none of the flags
550  // have changed, it's not necessary to even check for updates.
551 
552  // static variable, used to remember flags for next time.
553  static CommandFlag lastFlags;
554 
555  CommandFlag flags, quickFlags;
556 
557  const auto &options = Options();
558  size_t ii = 0;
559  for ( const auto &predicate : RegisteredPredicates() ) {
560  if ( options[ii].quickTest ) {
561  quickFlags[ii] = true;
562  if( predicate( mProject ) )
563  flags[ii] = true;
564  }
565  ++ii;
566  }
567 
568  if ( checkActive && !GetProjectFrame( mProject ).IsActive() )
569  // quick 'short-circuit' return.
570  flags = (lastFlags & ~quickFlags) | flags;
571  else {
572  ii = 0;
573  for ( const auto &predicate : RegisteredPredicates() ) {
574  if ( !options[ii].quickTest && predicate( mProject ) )
575  flags[ii] = true;
576  ++ii;
577  }
578  }
579 
580  lastFlags = flags;
581  return flags;
582 }

References GetProjectFrame(), anonymous_namespace{Menus.cpp}::Options(), and anonymous_namespace{Menus.cpp}::RegisteredPredicates().

Referenced by CommonTrackPanelCell::DoContextMenu(), CommandManager::FilterKeyEvent(), EditToolBar::OnButton(), ProjectWindow::OnMenu(), SelectUtilities::SelectAllIfNone(), and SelectUtilities::SelectAllIfNoneAndAllowed().

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

◆ ModifyAllProjectToolbarMenus()

void MenuManager::ModifyAllProjectToolbarMenus ( )
static

Definition at line 584 of file Menus.cpp.

585 {
586  for (auto pProject : AllProjects{}) {
587  auto &project = *pProject;
588  MenuManager::Get(project).ModifyToolbarMenus(project);
589  }
590 }

References Get(), and ModifyToolbarMenus().

Referenced by TrackActions::Handler::OnSyncLock(), TransportActions::Handler::OnTogglePlayRecording(), TransportActions::Handler::OnToggleSoundActivated(), TransportActions::Handler::OnToggleSWPlaythrough(), LabelEditActions::Handler::OnToggleTypeToCreateLabel(), and AdornedRulerPanel::TogglePinnedHead().

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

◆ ModifyToolbarMenus()

void MenuManager::ModifyToolbarMenus ( AudacityProject project)
static

Definition at line 592 of file Menus.cpp.

593 {
594  // Refreshes can occur during shutdown and the toolmanager may already
595  // be deleted, so protect against it.
596  auto &toolManager = ToolManager::Get( project );
597 
598  auto &settings = ProjectSettings::Get( project );
599 
600  // Now, go through each toolbar, and call EnableDisableButtons()
601  for (int i = 0; i < ToolBarCount; i++) {
602  auto bar = toolManager.GetToolBar(i);
603  if (bar)
604  bar->EnableDisableButtons();
605  }
606 
607  // These don't really belong here, but it's easier and especially so for
608  // the Edit toolbar and the sync-lock menu item.
609  bool active;
610 
611  gPrefs->Read(wxT("/GUI/SyncLockTracks"), &active, false);
612  settings.SetSyncLock(active);
613 
614  CommandManager::Get( project ).UpdateCheckmarks( project );
615 }

References CommandManager::Get(), ProjectSettings::Get(), ToolManager::Get(), gPrefs, settings(), ToolBarCount, and CommandManager::UpdateCheckmarks().

Referenced by ModifyAllProjectToolbarMenus(), ExtraActions::Handler::OnFullScreen(), ToolManager::OnResetToolBars(), AttachedToolBarMenuItem::OnShowToolBar(), and UpdateMenus().

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

◆ ModifyUndoMenuItems()

void MenuManager::ModifyUndoMenuItems ( AudacityProject project)
static

Definition at line 444 of file Menus.cpp.

445 {
447  auto &undoManager = UndoManager::Get( project );
448  auto &commandManager = CommandManager::Get( project );
449  int cur = undoManager.GetCurrentState();
450 
451  if (undoManager.UndoAvailable()) {
452  undoManager.GetShortDescription(cur, &desc);
453  commandManager.Modify(wxT("Undo"),
454  XXO("&Undo %s")
455  .Format( desc ));
456  commandManager.Enable(wxT("Undo"),
457  ProjectHistory::Get( project ).UndoAvailable());
458  }
459  else {
460  commandManager.Modify(wxT("Undo"),
461  XXO("&Undo"));
462  }
463 
464  if (undoManager.RedoAvailable()) {
465  undoManager.GetShortDescription(cur+1, &desc);
466  commandManager.Modify(wxT("Redo"),
467  XXO("&Redo %s")
468  .Format( desc ));
469  commandManager.Enable(wxT("Redo"),
470  ProjectHistory::Get( project ).RedoAvailable());
471  }
472  else {
473  commandManager.Modify(wxT("Redo"),
474  XXO("&Redo"));
475  commandManager.Enable(wxT("Redo"), false);
476  }
477 }

References desc, CommandManager::Get(), ProjectHistory::Get(), UndoManager::Get(), and XXO.

Referenced by anonymous_namespace{EditMenus.cpp}::EditMenu(), and PluginActions::Handler::OnApplyMacroDirectlyByName().

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

◆ OnUndoRedo()

void MenuManager::OnUndoRedo ( wxCommandEvent &  evt)
private

Definition at line 513 of file Menus.cpp.

514 {
515  evt.Skip();
517  UpdateMenus();
518 }

Referenced by ~MenuManager().

Here is the caller graph for this function:

◆ operator=()

MenuManager& MenuManager::operator= ( const MenuManager )

◆ ReportIfActionNotAllowed()

bool MenuManager::ReportIfActionNotAllowed ( const TranslatableString Name,
CommandFlag flags,
CommandFlag  flagsRqd 
)

Definition at line 697 of file Menus.cpp.

699 {
700  auto &project = mProject;
701  bool bAllowed = TryToMakeActionAllowed( flags, flagsRqd );
702  if( bAllowed )
703  return true;
704  auto &cm = CommandManager::Get( project );
705  TellUserWhyDisallowed( Name, flags & flagsRqd, flagsRqd);
706  return false;
707 }

References CommandManager::Get().

Referenced by CommandManager::HandleCommandEntry(), and EffectUIHost::OnApply().

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

◆ TellUserWhyDisallowed()

void MenuManager::TellUserWhyDisallowed ( const TranslatableString Name,
CommandFlag  flagsGot,
CommandFlag  flagsRequired 
)
private

Definition at line 743 of file Menus.cpp.

745 {
746  // The default string for 'reason' is a catch all. I hope it won't ever be seen
747  // and that we will get something more specific.
748  auto reason = XO("There was a problem with your last action. If you think\nthis is a bug, please tell us exactly where it occurred.");
749  // The default title string is 'Disallowed'.
750  auto untranslatedTitle = XO("Disallowed");
751  wxString helpPage;
752 
753  bool enableDefaultMessage = true;
754  bool defaultMessage = true;
755 
756  auto doOption = [&](const CommandFlagOptions &options) {
757  if ( options.message ) {
758  reason = options.message( Name );
759  defaultMessage = false;
760  if ( !options.title.empty() )
761  untranslatedTitle = options.title;
762  helpPage = options.helpPage;
763  return true;
764  }
765  else {
766  enableDefaultMessage =
767  enableDefaultMessage && options.enableDefaultMessage;
768  return false;
769  }
770  };
771 
772  const auto &alloptions = Options();
773  auto missingFlags = flagsRequired & ~flagsGot;
774 
775  // Find greatest priority
776  unsigned priority = 0;
777  for ( const auto &options : alloptions )
778  priority = std::max( priority, options.priority );
779 
780  // Visit all unsatisfied conditions' options, by descending priority,
781  // stopping when we find a message
782  ++priority;
783  while( priority-- ) {
784  size_t ii = 0;
785  for ( const auto &options : alloptions ) {
786  if (
787  priority == options.priority
788  &&
789  missingFlags[ii]
790  &&
791  doOption( options ) )
792  goto done;
793 
794  ++ii;
795  }
796  }
797  done:
798 
799  if (
800  // didn't find a message
801  defaultMessage
802  &&
803  // did find a condition that suppresses the default message
804  !enableDefaultMessage
805  )
806  return;
807 
808  // Does not have the warning icon...
810  untranslatedTitle,
811  reason,
812  helpPage);
813 }

References anonymous_namespace{Menus.cpp}::Options(), BasicUI::ShowErrorDialog(), and XO.

Here is the call graph for this function:

◆ TryToMakeActionAllowed()

bool MenuManager::TryToMakeActionAllowed ( CommandFlag flags,
CommandFlag  flagsRqd 
)

Determines if flags for command are compatible with current state. If not, then try some recovery action to make it so.

Returns
whether compatible or not after any actions taken.

Definition at line 712 of file Menus.cpp.

714 {
715  auto &project = mProject;
716 
717  if( flags.none() )
718  flags = GetUpdateFlags();
719 
720  // Visit the table of recovery actions
721  auto &enablers = Enablers();
722  auto iter = enablers.begin(), end = enablers.end();
723  while ((flags & flagsRqd) != flagsRqd && iter != end) {
724  const auto &enabler = *iter;
725  auto actual = enabler.actualFlags();
726  auto MissingFlags = (~flags & flagsRqd);
727  if (
728  // Do we have the right precondition?
729  (flags & actual) == actual
730  &&
731  // Can we get the condition we need?
732  (MissingFlags & enabler.possibleFlags()).any()
733  ) {
734  // Then try the function
735  enabler.tryEnable( project, flagsRqd );
736  flags = GetUpdateFlags();
737  }
738  ++iter;
739  }
740  return (flags & flagsRqd) == flagsRqd;
741 }

References anonymous_namespace{Menus.cpp}::Enablers().

Referenced by ProjectAudioManager::DoRecord().

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

◆ UpdateMenus()

void MenuManager::UpdateMenus ( bool  checkActive = true)

Definition at line 635 of file Menus.cpp.

636 {
637  auto &project = mProject;
638 
639  auto flags = GetUpdateFlags(checkActive);
640  // Return from this function if nothing's changed since
641  // the last time we were here.
642  if (flags == mLastFlags)
643  return;
644  mLastFlags = flags;
645 
646  auto flags2 = flags;
647 
648  // We can enable some extra items if we have select-all-on-none.
649  //EXPLAIN-ME: Why is this here rather than in GetUpdateFlags()?
650  //ANSWER: Because flags2 is used in the menu enable/disable.
651  //The effect still needs flags to determine whether it will need
652  //to actually do the 'select all' to make the command valid.
653 
654  for ( const auto &enabler : Enablers() ) {
655  auto actual = enabler.actualFlags();
656  if (
657  enabler.applicable( project ) && (flags & actual) == actual
658  )
659  flags2 |= enabler.possibleFlags();
660  }
661 
662  auto &commandManager = CommandManager::Get( project );
663 
664  // With select-all-on-none, some items that we don't want enabled may have
665  // been enabled, since we changed the flags. Here we manually disable them.
666  // 0 is grey out, 1 is Autoselect, 2 is Give warnings.
667  commandManager.EnableUsingFlags(
668  flags2, // the "lax" flags
669  (mWhatIfNoSelection == 0 ? flags2 : flags) // the "strict" flags
670  );
671 
673 }

References anonymous_namespace{Menus.cpp}::Enablers(), CommandManager::Get(), and ModifyToolbarMenus().

Referenced by MacroCommands::ApplyCommandInBatchMode(), EffectUI::DoEffect(), ProjectWindow::FixScrollbars(), and ProjectWindow::OnUpdateUI().

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

◆ UpdatePrefs()

void MenuManager::UpdatePrefs ( )
overridevirtual

Implements PrefsListener.

Definition at line 97 of file Menus.cpp.

98 {
99  bool bSelectAllIfNone;
100  gPrefs->Read(wxT("/GUI/SelectAllOnNone"), &bSelectAllIfNone, false);
101  // 0 is grey out, 1 is Autoselect, 2 is Give warnings.
102 #ifdef EXPERIMENTAL_DA
103  // DA warns or greys out.
104  mWhatIfNoSelection = bSelectAllIfNone ? 2 : 0;
105 #else
106  // Audacity autoselects or warns.
107  mWhatIfNoSelection = bSelectAllIfNone ? 1 : 2;
108 #endif
109  mStopIfWasPaused = true; // not configurable for now, but could be later.
110 }

References gPrefs, mStopIfWasPaused, and mWhatIfNoSelection.

◆ Visit()

void MenuManager::Visit ( ToolbarMenuVisitor visitor)
static

Definition at line 437 of file Menus.cpp.

438 {
439  static const auto menuTree = MenuTable::Items( MenuPathStart );
440  Registry::Visit( visitor, menuTree.get(), &sRegistry() );
441 }

References MenuTable::Items(), MenuPathStart, anonymous_namespace{Menus.cpp}::sRegistry(), and Registry::Visit().

Referenced by MenuCreator::CreateMenusAndCommands(), and HelpActions::Handler::OnMenuTree().

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

Member Data Documentation

◆ mProject

AudacityProject& MenuManager::mProject
private

Definition at line 118 of file Menus.h.

Referenced by ~MenuManager().

◆ mStopIfWasPaused

bool MenuManager::mStopIfWasPaused

Definition at line 123 of file Menus.h.

Referenced by UpdatePrefs().

◆ mWhatIfNoSelection

int MenuManager::mWhatIfNoSelection

Definition at line 122 of file Menus.h.

Referenced by UpdatePrefs().


The documentation for this class was generated from the following files:
TranslatableString
Holds a msgid for the translation catalog; may also bind format arguments.
Definition: TranslatableString.h:32
ToolBarCount
@ ToolBarCount
Definition: ToolBar.h:87
MenuManager
MenuManager handles updates to menu state.
Definition: Menus.h:77
MenuCreator::mLastFlags
CommandFlag mLastFlags
Definition: Menus.h:48
gPrefs
FileConfig * gPrefs
Definition: Prefs.cpp:70
MenuManager::UpdatePrefs
void UpdatePrefs() override
Definition: Menus.cpp:97
BasicUI::ShowErrorDialog
void ShowErrorDialog(const WindowPlacement &placement, const TranslatableString &dlogTitle, const TranslatableString &message, const ManualPageID &helpPage, const ErrorDialogOptions &options={})
Show an error dialog with a link to the manual for further help.
Definition: BasicUI.h:233
Format
Abstract base class used in importing a file.
ToolManager::Get
static ToolManager & Get(AudacityProject &project)
Definition: ToolManager.cpp:356
MenuManager::TellUserWhyDisallowed
void TellUserWhyDisallowed(const TranslatableString &Name, CommandFlag flagsGot, CommandFlag flagsRequired)
Definition: Menus.cpp:743
XO
#define XO(s)
Definition: Internat.h:31
ProjectSettings::Get
static ProjectSettings & Get(AudacityProject &project)
Definition: ProjectSettings.cpp:44
anonymous_namespace{Menus.cpp}::Enablers
MenuItemEnablers & Enablers()
Definition: Menus.cpp:620
CommandFlag
std::bitset< NCommandFlags > CommandFlag
Definition: CommandFlag.h:31
desc
const TranslatableString desc
Definition: ExportPCM.cpp:58
XXO
#define XXO(s)
Definition: Internat.h:44
MenuManager::UpdateMenus
void UpdateMenus(bool checkActive=true)
Definition: Menus.cpp:635
MenuManager::mWhatIfNoSelection
int mWhatIfNoSelection
Definition: Menus.h:122
MenuTable::Items
std::unique_ptr< MenuItems > Items(const Identifier &internalName, Args &&... args)
Definition: CommandManager.h:600
MenuManager::mProject
AudacityProject & mProject
Definition: Menus.h:118
CommandManager::UpdateCheckmarks
void UpdateCheckmarks(AudacityProject &project)
Definition: CommandManager.cpp:535
anonymous_namespace{Menus.cpp}::RegisteredPredicates
Predicates & RegisteredPredicates()
Definition: Menus.cpp:522
CommandFlagOptions
Definition: CommandFlag.h:38
MenuManager::TryToMakeActionAllowed
bool TryToMakeActionAllowed(CommandFlag &flags, CommandFlag flagsRqd)
Definition: Menus.cpp:712
Registry::Visit
void Visit(Visitor &visitor, BaseItem *pTopItem, const GroupItem *pRegistry)
Definition: Registry.cpp:713
MenuManager::OnUndoRedo
void OnUndoRedo(wxCommandEvent &evt)
Definition: Menus.cpp:513
UndoManager::Get
static UndoManager & Get(AudacityProject &project)
Definition: UndoManager.cpp:57
AudacityProject
The top-level handle to an Audacity project. It serves as a source of events that other objects can b...
Definition: Project.h:92
GetProjectFrame
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 ...
Definition: ProjectWindows.cpp:72
MenuManager::Get
static MenuManager & Get(AudacityProject &project)
Definition: Menus.cpp:70
AllProjects
Definition: Project.h:35
key
static const AudacityProject::AttachedObjects::RegisteredFactory key
Definition: Menus.cpp:65
anonymous_namespace{Menus.cpp}::sRegistry
static Registry::GroupItem & sRegistry()
Definition: Menus.cpp:258
MenuPathStart
static const auto MenuPathStart
Definition: WaveTrackControls.cpp:483
CommandManager::Get
static CommandManager & Get(AudacityProject &project)
Definition: CommandManager.cpp:207
MenuManager::ModifyUndoMenuItems
static void ModifyUndoMenuItems(AudacityProject &project)
Definition: Menus.cpp:444
settings
static Settings & settings()
Definition: TrackInfo.cpp:86
anonymous_namespace{Menus.cpp}::Options
std::vector< CommandFlagOptions > & Options()
Definition: Menus.cpp:527
MenuManager::mStopIfWasPaused
bool mStopIfWasPaused
Definition: Menus.h:123
MenuManager::ModifyToolbarMenus
static void ModifyToolbarMenus(AudacityProject &project)
Definition: Menus.cpp:592
MenuManager::GetUpdateFlags
CommandFlag GetUpdateFlags(bool checkActive=false) const
Definition: Menus.cpp:545
ProjectHistory::Get
static ProjectHistory & Get(AudacityProject &project)
Definition: ProjectHistory.cpp:26