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 &)=delete
MenuManager &	operator= (const MenuManager &)=delete
	~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 ()
Public Member Functions inherited from Observer::Publisher< MenuUpdateMessage >
	Publisher (ExceptionPolicy *pPolicy=nullptr, Alloc a={})
	Constructor supporting type-erased custom allocation/deletion. More...
	Publisher (Publisher &&)=default
Publisher &	operator= (Publisher &&)=default
Subscription	Subscribe (Callback callback)
	Connect a callback to the Publisher; later-connected are called earlier. More...
Subscription	Subscribe (Object &obj, Return(Object::*callback)(Args...))
	Overload of Subscribe takes an object and pointer-to-member-function. More...

Static Public Member Functions
static MenuManager &	Get (AudacityProject &project)
static const MenuManager &	Get (const AudacityProject &project)
static void	Visit (MenuTable::Visitor< MenuTable::Traits > &visitor, AudacityProject &project)
static void	ModifyUndoMenuItems (AudacityProject &project)
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 }
Public Types inherited from Observer::Publisher< MenuUpdateMessage >
using	message_type = MenuUpdateMessage
using	CallbackReturn = std::conditional_t< true, void, bool >
using	Callback = std::function< CallbackReturn(const MenuUpdateMessage &) >
	Type of functions that can be connected to the Publisher. More...
Static Public Attributes inherited from Observer::Publisher< MenuUpdateMessage >
static constexpr bool	notifies_all
Protected Member Functions inherited from Observer::Publisher< MenuUpdateMessage >
CallbackReturn	Publish (const MenuUpdateMessage &message)
	Send a message to connected callbacks. More...
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 77 of file Menus.h.

Constructor & Destructor Documentation

MenuManager() [1/2]

MenuManager::MenuManager ( AudacityProject &  project )

explicit

Definition at line 79 of file Menus.cpp.

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

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

Here is the call graph for this function:

MenuManager() [2/2]

MenuManager::MenuManager ( const MenuManager &  )

delete

~MenuManager()

MenuManager::~MenuManager

(

)

Definition at line 87 of file Menus.cpp.

{
}

Member Function Documentation

Get() [1/2]

MenuManager & MenuManager::Get ( AudacityProject &  project )

static

Definition at line 69 of file Menus.cpp.

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

References key, and project.

Referenced by anonymous_namespace{PluginMenus.cpp}::AnalyzeMenu(), MacroCommands::ApplyCommandInBatchMode(), ToolManager::CreateWindows(), 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{BatchProcessDialog.cpp}::HasLastToolFlag(), ProjectManager::New(), EffectUIHost::OnApply(), anonymous_namespace{BatchProcessDialog.cpp}::OnApplyMacroDirectlyByName(), ToolBarButtons::OnButton(), ProjectWindow::OnMenu(), anonymous_namespace{EditMenus.cpp}::OnPreferences(), anonymous_namespace{PluginMenus.cpp}::OnRepeatLastAnalyzer(), anonymous_namespace{PluginMenus.cpp}::OnRepeatLastEffect(), anonymous_namespace{PluginMenus.cpp}::OnRepeatLastGenerator(), anonymous_namespace{BatchProcessDialog.cpp}::OnRepeatLastTool(), anonymous_namespace{PluginMenus.cpp}::OnResetConfig(), ProjectWindow::OnUpdateUI(), PluginMenuItems(), MenuCreator::RebuildAllMenuBars(), CommandManager::RegisterLastAnalyzer(), CommandManager::RegisterLastTool(), SelectUtilities::SelectAllIfNone(), SelectUtilities::SelectAllIfNoneAndAllowed(), 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 74 of file Menus.cpp.

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

References Get(), and project.

Here is the call graph for this function:

GetUpdateFlags()

CommandFlag MenuManager::GetUpdateFlags

(

bool

checkActive = false

)

const

Definition at line 517 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 = ReservedCommandFlag::Options();
   size_t ii = 0;
   for ( const auto &predicate : ReservedCommandFlag::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
           : ReservedCommandFlag::RegisteredPredicates() ) {
         if ( !options[ii].quickTest && predicate( mProject ) )
            flags[ii] = true;
         ++ii;
      }
   }
 
   lastFlags = flags;
   return flags;
}

References GetProjectFrame(), mProject, ReservedCommandFlag::Options(), and ReservedCommandFlag::RegisteredPredicates().

Referenced by CommandManager::FilterKeyEvent(), ToolBarButtons::OnButton(), ProjectWindow::OnMenu(), SelectUtilities::SelectAllIfNone(), SelectUtilities::SelectAllIfNoneAndAllowed(), TryToMakeActionAllowed(), 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 433 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 anonymous_namespace{ExportPCM.cpp}::desc, ProjectHistory::Get(), UndoManager::Get(), CommandManager::Get(), project, wxT(), and XXO().

Referenced by anonymous_namespace{EditMenus.cpp}::EditMenu(), anonymous_namespace{BatchProcessDialog.cpp}::OnApplyMacroDirectlyByName(), and OnUndoRedo().

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 502 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 ModifyUndoMenuItems(), mProject, UndoRedoMessage::Pushed, UndoRedoMessage::Renamed, UndoRedoMessage::Reset, UndoRedoMessage::type, UndoRedoMessage::UndoOrRedo, and UpdateMenus().

Referenced by MenuManager().

Here is the call graph for this function:

Here is the caller graph for this function:

operator=()

MenuManager & MenuManager::operator= ( const MenuManager &  )

delete

ReportIfActionNotAllowed()

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

Definition at line 621 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(), mProject, project, TellUserWhyDisallowed(), and TryToMakeActionAllowed().

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 667 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 = ReservedCommandFlag::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 ReservedCommandFlag::Options(), BasicUI::ShowErrorDialog(), and XO().

Referenced by ReportIfActionNotAllowed().

Here is the call graph for this function:

Here is the caller 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 636 of file Menus.cpp.

{
   auto &project = mProject;
 
   if( flags.none() )
      flags = GetUpdateFlags();
 
   // Visit the table of recovery actions
   auto &enablers = RegisteredMenuItemEnabler::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 RegisteredMenuItemEnabler::Enablers(), PackedArray::end(), GetUpdateFlags(), mProject, and project.

Referenced by ProjectAudioManager::DoRecord(), and ReportIfActionNotAllowed().

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 559 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 : RegisteredMenuItemEnabler::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
   );
 
   Publish({});
}

References RegisteredMenuItemEnabler::Enablers(), CommandManager::Get(), GetUpdateFlags(), MenuCreator::mLastFlags, mProject, mWhatIfNoSelection, project, and Observer::Publisher< MenuUpdateMessage >::Publish().

Referenced by MacroCommands::ApplyCommandInBatchMode(), EffectUI::DoEffect(), ProjectWindow::FixScrollbars(), OnUndoRedo(), 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 91 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, audacity::BasicSettings::Read(), 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 ( MenuTable::Visitor< MenuTable::Traits > &  visitor, AudacityProject &  project  )

static

Definition at line 422 of file Menus.cpp.

{
   static const auto menuTree = MenuTable::Items( MenuPathStart );
 
   wxLogNull nolog;
   Registry::VisitWithFunctions(visitor, menuTree.get(),
      &MenuTable::ItemRegistry::Registry(), project);
}

References MenuTable::Items, MenuPathStart, project, MenuTable::ItemRegistry::Registry(), and Registry::VisitWithFunctions().

Referenced by MenuCreator::CreateMenusAndCommands(), and anonymous_namespace{HelpMenus.cpp}::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 122 of file Menus.h.

Referenced by GetUpdateFlags(), OnUndoRedo(), ReportIfActionNotAllowed(), TryToMakeActionAllowed(), and UpdateMenus().

mStopIfWasPaused

bool MenuManager::mStopIfWasPaused

Definition at line 127 of file Menus.h.

Referenced by UpdatePrefs().

mUndoSubscription

Observer::Subscription MenuManager::mUndoSubscription

private

Definition at line 121 of file Menus.h.

Referenced by MenuManager().

mWhatIfNoSelection

int MenuManager::mWhatIfNoSelection

Definition at line 126 of file Menus.h.

Referenced by UpdateMenus(), and UpdatePrefs().

---

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

• Menus.h
• Menus.cpp