MenuManager Class Reference

MenuManager handles updates to menu state. More...

#include <Menus.h>

Inheritance diagram for MenuManager:

Collaboration diagram for MenuManager:

Public Member Functions
	MenuManager (AudacityProject &project)
	MenuManager (const MenuManager &) PROHIBITED
MenuManager &	operator= (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 MenuManager &	Get (AudacityProject &project)
static const MenuManager &	Get (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
AudacityProject &	mProject

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.

   : mProject{ project }
{
   UpdatePrefs();
   mProject.Bind( EVT_UNDO_OR_REDO, &MenuManager::OnUndoRedo, this );
   mProject.Bind( EVT_UNDO_RESET, &MenuManager::OnUndoRedo, this );
   mProject.Bind( EVT_UNDO_PUSHED, &MenuManager::OnUndoRedo, this );
   mProject.Bind( EVT_UNDO_RENAMED, &MenuManager::OnUndoRedo, this );
}

MenuManager() [2/2]

MenuManager::MenuManager

(

const MenuManager &

)

~MenuManager()

MenuManager::~MenuManager

(

)

Definition at line 90 of file Menus.cpp.

{
   mProject.Unbind( EVT_UNDO_OR_REDO, &MenuManager::OnUndoRedo, this );
   mProject.Unbind( EVT_UNDO_RESET, &MenuManager::OnUndoRedo, this );
   mProject.Unbind( EVT_UNDO_PUSHED, &MenuManager::OnUndoRedo, this );
}

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.

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

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.

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

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.

{
   // This method determines all of the flags that determine whether
   // certain menu items and commands should be enabled or disabled,
   // and returns them in a bitfield.  Note that if none of the flags
   // have changed, it's not necessary to even check for updates.
 
   // static variable, used to remember flags for next time.
   static CommandFlag lastFlags;
 
   CommandFlag flags, quickFlags;
 
   const auto &options = Options();
   size_t ii = 0;
   for ( const auto &predicate : RegisteredPredicates() ) {
      if ( options[ii].quickTest ) {
         quickFlags[ii] = true;
         if( predicate( mProject ) )
            flags[ii] = true;
      }
      ++ii;
   }
 
   if ( checkActive && !GetProjectFrame( mProject ).IsActive() )
      // quick 'short-circuit' return.
      flags = (lastFlags & ~quickFlags) | flags;
   else {
      ii = 0;
      for ( const auto &predicate : RegisteredPredicates() ) {
         if ( !options[ii].quickTest && predicate( mProject ) )
            flags[ii] = true;
         ++ii;
      }
   }
 
   lastFlags = flags;
   return flags;
}

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.

{
   for (auto pProject : AllProjects{}) {
      auto &project = *pProject;
      MenuManager::Get(project).ModifyToolbarMenus(project);
   }
}

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.

{
   // Refreshes can occur during shutdown and the toolmanager may already
   // be deleted, so protect against it.
   auto &toolManager = ToolManager::Get( project );
 
   auto &settings = ProjectSettings::Get( project );
 
   // Now, go through each toolbar, and call EnableDisableButtons()
   for (int i = 0; i < ToolBarCount; i++) {
      auto bar = toolManager.GetToolBar(i);
      if (bar)
         bar->EnableDisableButtons();
   }
 
   // These don't really belong here, but it's easier and especially so for
   // the Edit toolbar and the sync-lock menu item.
   bool active;
 
   gPrefs->Read(wxT("/GUI/SyncLockTracks"), &active, false);
   settings.SetSyncLock(active);
 
   CommandManager::Get( project ).UpdateCheckmarks( project );
}

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.

{
   TranslatableString desc;
   auto &undoManager = UndoManager::Get( project );
   auto &commandManager = CommandManager::Get( project );
   int cur = undoManager.GetCurrentState();
 
   if (undoManager.UndoAvailable()) {
      undoManager.GetShortDescription(cur, &desc);
      commandManager.Modify(wxT("Undo"),
         XXO("&Undo %s")
            .Format( desc ));
      commandManager.Enable(wxT("Undo"),
         ProjectHistory::Get( project ).UndoAvailable());
   }
   else {
      commandManager.Modify(wxT("Undo"),
                            XXO("&Undo"));
   }
 
   if (undoManager.RedoAvailable()) {
      undoManager.GetShortDescription(cur+1, &desc);
      commandManager.Modify(wxT("Redo"),
         XXO("&Redo %s")
            .Format( desc ));
      commandManager.Enable(wxT("Redo"),
         ProjectHistory::Get( project ).RedoAvailable());
   }
   else {
      commandManager.Modify(wxT("Redo"),
                            XXO("&Redo"));
      commandManager.Enable(wxT("Redo"), false);
   }
}

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.

{
   evt.Skip();
   ModifyUndoMenuItems( mProject );
   UpdateMenus();
}

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.

{
   auto &project = mProject;
   bool bAllowed = TryToMakeActionAllowed( flags, flagsRqd );
   if( bAllowed )
      return true;
   auto &cm = CommandManager::Get( project );
   TellUserWhyDisallowed( Name, flags & flagsRqd, flagsRqd);
   return false;
}

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.

{
   // The default string for 'reason' is a catch all.  I hope it won't ever be seen
   // and that we will get something more specific.
   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.");
   // The default title string is 'Disallowed'.
   auto untranslatedTitle = XO("Disallowed");
   wxString helpPage;
 
   bool enableDefaultMessage = true;
   bool defaultMessage = true;
 
   auto doOption = [&](const CommandFlagOptions &options) {
      if ( options.message ) {
         reason = options.message( Name );
         defaultMessage = false;
         if ( !options.title.empty() )
            untranslatedTitle = options.title;
         helpPage = options.helpPage;
         return true;
      }
      else {
         enableDefaultMessage =
            enableDefaultMessage && options.enableDefaultMessage;
         return false;
      }
   };
 
   const auto &alloptions = Options();
   auto missingFlags = flagsRequired & ~flagsGot;
 
   // Find greatest priority
   unsigned priority = 0;
   for ( const auto &options : alloptions )
      priority = std::max( priority, options.priority );
 
   // Visit all unsatisfied conditions' options, by descending priority,
   // stopping when we find a message
   ++priority;
   while( priority-- ) {
      size_t ii = 0;
      for ( const auto &options : alloptions ) {
         if (
            priority == options.priority
         &&
            missingFlags[ii]
         &&
            doOption( options ) )
            goto done;
 
         ++ii;
      }
   }
   done:
 
   if (
      // didn't find a message
      defaultMessage
   &&
      // did find a condition that suppresses the default message
      !enableDefaultMessage
   )
      return;
 
   // Does not have the warning icon...
   BasicUI::ShowErrorDialog( {},
      untranslatedTitle,
      reason,
      helpPage);
}

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.

{
   auto &project = mProject;
 
   if( flags.none() )
      flags = GetUpdateFlags();
 
   // Visit the table of recovery actions
   auto &enablers = Enablers();
   auto iter = enablers.begin(), end = enablers.end();
   while ((flags & flagsRqd) != flagsRqd && iter != end) {
      const auto &enabler = *iter;
      auto actual = enabler.actualFlags();
      auto MissingFlags = (~flags & flagsRqd);
      if (
         // Do we have the right precondition?
         (flags & actual) == actual
      &&
         // Can we get the condition we need?
         (MissingFlags & enabler.possibleFlags()).any()
      ) {
         // Then try the function
         enabler.tryEnable( project, flagsRqd );
         flags = GetUpdateFlags();
      }
      ++iter;
   }
   return (flags & flagsRqd) == flagsRqd;
}

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.

{
   auto &project = mProject;
 
   auto flags = GetUpdateFlags(checkActive);
   // Return from this function if nothing's changed since
   // the last time we were here.
   if (flags == mLastFlags)
      return;
   mLastFlags = flags;
 
   auto flags2 = flags;
 
   // We can enable some extra items if we have select-all-on-none.
   //EXPLAIN-ME: Why is this here rather than in GetUpdateFlags()?
   //ANSWER: Because flags2 is used in the menu enable/disable.
   //The effect still needs flags to determine whether it will need
   //to actually do the 'select all' to make the command valid.
 
   for ( const auto &enabler : Enablers() ) {
      auto actual = enabler.actualFlags();
      if (
         enabler.applicable( project ) && (flags & actual) == actual
      )
         flags2 |= enabler.possibleFlags();
   }
 
   auto &commandManager = CommandManager::Get( project );
 
   // With select-all-on-none, some items that we don't want enabled may have
   // been enabled, since we changed the flags.  Here we manually disable them.
   // 0 is grey out, 1 is Autoselect, 2 is Give warnings.
   commandManager.EnableUsingFlags(
      flags2, // the "lax" flags
      (mWhatIfNoSelection == 0 ? flags2 : flags) // the "strict" flags
   );
 
   MenuManager::ModifyToolbarMenus(project);
}

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.

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

References gPrefs, mStopIfWasPaused, and mWhatIfNoSelection.

Visit()

void MenuManager::Visit ( ToolbarMenuVisitor &  visitor )

static

Definition at line 437 of file Menus.cpp.

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

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:

• Menus.h
• Menus.cpp