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 (struct UndoRedoMessage)
Private Member Functions inherited from PrefsListener
	PrefsListener ()
virtual	~PrefsListener ()
virtual void	UpdatePrefs ()=0
virtual void	UpdateSelectedPrefs (int id)

Private Attributes
Observer::Subscription	mUndoSubscription
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 74 of file Menus.h.

Constructor & Destructor Documentation

MenuManager() [1/2]

MenuManager::MenuManager ( AudacityProject &  project )

explicit

Definition at line 81 of file Menus.cpp.

   : mProject{ project }
{
   UpdatePrefs();
   mUndoSubscription = UndoManager::Get(project)
      .Subscribe(*this, &MenuManager::OnUndoRedo);
}

References UndoManager::Get(), mUndoSubscription, OnUndoRedo(), Observer::Publisher< Message, NotifyAll >::Subscribe(), and UpdatePrefs().

Here is the call graph for this function:

MenuManager() [2/2]

MenuManager::MenuManager

(

const MenuManager &

)

~MenuManager()

MenuManager::~MenuManager

(

)

Definition at line 89 of file Menus.cpp.

{
}

Member Function Documentation

Get() [1/2]

MenuManager & MenuManager::Get ( AudacityProject &  project )

static

Definition at line 71 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(), anonymous_namespace{WindowMenus.cpp}::DoMacMinimize(), 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 76 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 553 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 592 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 600 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, CommandManager::UpdateCheckmarks(), and wxT().

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, ProjectHistory::Get(), UndoManager::Get(), CommandManager::Get(), wxT(), 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 ( struct UndoRedoMessage  message )

private

Definition at line 513 of file Menus.cpp.

{
   switch (message.type) {
   case UndoRedoMessage::UndoOrRedo:
   case UndoRedoMessage::Reset:
   case UndoRedoMessage::Pushed:
   case UndoRedoMessage::Renamed:
      break;
   default:
      return;
   }
   ModifyUndoMenuItems( mProject );
   UpdateMenus();
}

References UndoRedoMessage::Pushed, UndoRedoMessage::Renamed, UndoRedoMessage::Reset, UndoRedoMessage::type, and UndoRedoMessage::UndoOrRedo.

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 705 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 751 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 720 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(), and PackedArray::end().

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 643 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(), anonymous_namespace{WindowMenus.cpp}::DoMacMinimize(), 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 93 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, mWhatIfNoSelection, and wxT().

Referenced by MenuManager().

Here is the call graph for this function:

Here is the caller graph for this function:

Visit()

void MenuManager::Visit ( ToolbarMenuVisitor &  visitor )

static

Definition at line 435 of file Menus.cpp.

{
   static const auto menuTree = MenuTable::Items( MenuPathStart );
 
   wxLogNull nolog;
   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 120 of file Menus.h.

mStopIfWasPaused

bool MenuManager::mStopIfWasPaused

Definition at line 125 of file Menus.h.

Referenced by UpdatePrefs().

mUndoSubscription

Observer::Subscription MenuManager::mUndoSubscription

private

Definition at line 119 of file Menus.h.

Referenced by MenuManager().

mWhatIfNoSelection

int MenuManager::mWhatIfNoSelection

Definition at line 124 of file Menus.h.

Referenced by UpdatePrefs().

---

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

• Menus.h
• Menus.cpp