CommandManager implements a system for organizing all user-callable commands. More...

#include <CommandManager.h>

Inheritance diagram for CommandManager:

Collaboration diagram for CommandManager:

Classes
struct	CommandListEntry

struct	Factory

struct	GlobalMenuHook

struct	Populator

Public Types
enum	{ repeattypenone = 0 , repeattypeplugin = 1 , repeattypeunique = 2 , repeattypeapplymacro = 3 }

enum	TextualCommandResult { CommandFailure , CommandSuccess , CommandNotFound }

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...

Public Member Functions
	CommandManager (AudacityProject &project)

	CommandManager (const CommandManager &)=delete

CommandManager &	operator= (const CommandManager &)=delete

	~CommandManager () override

CommandFlag	GetUpdateFlags (bool quick=false) const

void	UpdatePrefs () override

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

bool	TryToMakeActionAllowed (CommandFlag &flags, CommandFlag flagsRqd)

AudacityProject &	GetProject ()

size_t	NCommands () const

void	PurgeData ()

void	SetCommandFlags (const CommandID &name, CommandFlag flags)

void	EnableUsingFlags (CommandFlag flags, CommandFlag strictFlags)

void	Enable (const wxString &name, bool enabled)

void	Check (const CommandID &name, bool checked)

void	Modify (const wxString &name, const TranslatableString &newLabel)
	Changes the label text of a menu item. More...

void	SetKeyFromName (const CommandID &name, const NormalizedKeyString &key)

void	SetKeyFromIndex (int i, const NormalizedKeyString &key)

bool	HandleMenuID (int id, CommandFlag flags, bool alwaysEnabled)

void	RegisterLastAnalyzer (const CommandContext &context)

void	RegisterLastTool (const CommandContext &context)

void	DoRepeatProcess (const CommandContext &context, int)

TextualCommandResult	HandleTextualCommand (const CommandID &Str, const CommandContext &context, CommandFlag flags, bool alwaysEnabled)

TranslatableStrings	GetCategories ()

void	GetAllCommandNames (CommandIDs &names, bool includeMultis) const

void	GetAllCommandLabels (TranslatableStrings &labels, std::vector< bool > &vExcludeFromMacros, bool includeMultis) const

void	GetAllCommandData (CommandIDs &names, std::vector< NormalizedKeyString > &keys, std::vector< NormalizedKeyString > &default_keys, TranslatableStrings &labels, TranslatableStrings &categories, TranslatableStrings &prefixes, bool includeMultis)

CommandID	GetNameFromNumericID (int id) const

TranslatableString	GetLabelFromName (const CommandID &name) const

TranslatableString	GetPrefixedLabelFromName (const CommandID &name) const

TranslatableString	GetCategoryFromName (const CommandID &name) const

NormalizedKeyString	GetKeyFromName (const CommandID &name) const

NormalizedKeyString	GetDefaultKeyFromName (const CommandID &name) const

bool	GetEnabled (const CommandID &name) const

int	GetNumberOfKeysRead () const

TranslatableString	ReportDuplicateShortcuts ()

void	WriteXML (XMLWriter &xmlFile) const

TranslatableString	DescribeCommandsAndShortcuts (const ComponentInterfaceSymbol commands[], size_t nCommands) const

void	UpdateCheckmarks ()

wxString	FormatLabelForMenu (const CommandID &id, const TranslatableString *pLabel) const
	Format a string appropriate for insertion in a menu. More...

void	ModifyUndoMenuItems ()

void	UpdateMenus (bool checkActive=true)

Public Member Functions inherited from XMLTagHandler
	XMLTagHandler ()

virtual	~XMLTagHandler ()

virtual bool	HandleXMLTag (const std::string_view &tag, const AttributesList &attrs)=0

virtual void	HandleXMLEndTag (const std::string_view &WXUNUSED(tag))

virtual void	HandleXMLContent (const std::string_view &WXUNUSED(content))

virtual XMLTagHandler *	HandleXMLChild (const std::string_view &tag)=0

void	ReadXMLEndTag (const char *tag)

void	ReadXMLContent (const char *s, int len)

XMLTagHandler *	ReadXMLChild (const char *tag)

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 CommandManager &	Get (AudacityProject &project)

static const CommandManager &	Get (const AudacityProject &project)

static const std::vector< NormalizedKeyString > &	ExcludedList ()

Public Attributes
CommandFlag	mLastFlags = AlwaysEnabledFlag

PluginID	mLastGenerator {}

PluginID	mLastEffect {}

PluginID	mLastAnalyzer {}

int	mLastAnalyzerRegistration = repeattypenone

int	mLastAnalyzerRegisteredId = -1

PluginID	mLastTool {}

int	mLastToolRegistration = repeattypenone

int	mLastToolRegisteredId = -1

unsigned	mRepeatGeneratorFlags = 0

unsigned	mRepeatEffectFlags = 0

unsigned	mRepeatAnalyzerFlags = 0

unsigned	mRepeatToolFlags = 0

int	mWhatIfNoSelection

bool	mStopIfWasPaused { true }

Protected Types
using	CommandKeyHash = std::unordered_map< NormalizedKeyString, CommandListEntry * >

Protected Member Functions
bool	HandleCommandEntry (const CommandListEntry entry, CommandFlag flags, bool alwaysEnabled, const wxEvent evt=nullptr, const CommandContext *pGivenContext=nullptr)

virtual void	ExecuteCommand (const CommandContext &context, const wxEvent *evt, const CommandListEntry &entry)

virtual bool	ReallyDoQuickCheck ()
	Default implementation returns true. More...

Protected Member Functions inherited from Observer::Publisher< MenuUpdateMessage >
CallbackReturn	Publish (const MenuUpdateMessage &message)
	Send a message to connected callbacks. More...

Protected Attributes
AudacityProject &	mProject

CommandKeyHash	mCommandKeyHash

Static Protected Attributes
static const TranslatableString	COMMAND = XO("Command")

Private Types
using	CommandList = std::vector< std::unique_ptr< CommandListEntry > >

using	CommandNameHash = std::unordered_map< CommandID, CommandListEntry * >

using	CommandNumericIDHash = std::unordered_map< int, CommandListEntry * >

Private Member Functions
void	Enable (CommandListEntry &entry, bool enabled)

bool	HandleXMLTag (const std::string_view &tag, const AttributesList &attrs) override

void	HandleXMLEndTag (const std::string_view &tag) override

XMLTagHandler *	HandleXMLChild (const std::string_view &tag) override

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)

Static Private Member Functions
static int	NextIdentifier (int ID)

Static Private Member Functions inherited from PrefsListener
static void	Broadcast (int id=0)
	Call this static function to notify all PrefsListener objects. More...

Private Attributes
CommandList	mCommandList

CommandNameHash	mCommandNameHash

CommandNumericIDHash	mCommandNumericIDHash

int	mXMLKeysRead

TranslatableString	mNiceName

int	mLastProcessId

const Observer::Subscription	mUndoSubscription

Additional Inherited Members
Static Public Attributes inherited from Observer::Publisher< MenuUpdateMessage >
static constexpr bool	notifies_all

Detailed Description

CommandManager implements a system for organizing all user-callable commands.

It creates and manages a menu bar with a command associated with each item, and managing other commands callable by keyboard shortcuts.

Commands are implemented by overriding an abstract functor class. See Menus.cpp for an example use.

Menus or submenus containing lists of items can be added at once, with a single function (functor) to be called when any of the items is selected, with the index number of the selection as the parameter. This is useful for dynamic menus (effects) and submenus containing a list of choices (selection formats).

Menu items can be enabled or disabled individually, groups of "multi-items" can be enabled or disabled all at once, or entire sets of commands can be enabled or disabled all at once using flags. The flags should be a bitfield stored in a 32-bit integer but can be whatever you want. You specify both the desired values of the flags, and the set of flags relevant to a particular command, by using a combination of a flags parameter and a mask parameter. Any flag set to 0 in the mask parameter is the same as "don't care". Any command whose mask is set to zero will not be affected by enabling/disabling by flags.

Definition at line 49 of file CommandManager.h.

Member Typedef Documentation

◆ CommandKeyHash

using CommandManager::CommandKeyHash = std::unordered_map<NormalizedKeyString, CommandListEntry*>

protected

Definition at line 431 of file CommandManager.h.

◆ CommandList

using CommandManager::CommandList = std::vector<std::unique_ptr<CommandListEntry> >

private

Definition at line 441 of file CommandManager.h.

◆ CommandNameHash

using CommandManager::CommandNameHash = std::unordered_map<CommandID, CommandListEntry*>

private

Definition at line 445 of file CommandManager.h.

◆ CommandNumericIDHash

using CommandManager::CommandNumericIDHash = std::unordered_map<int, CommandListEntry*>

private

Definition at line 450 of file CommandManager.h.

Member Enumeration Documentation

◆ anonymous enum

anonymous enum

Enumerator
repeattypenone
repeattypeplugin
repeattypeunique
repeattypeapplymacro

Definition at line 100 of file CommandManager.h.

        {
      repeattypenone = 0,
      repeattypeplugin = 1,
      repeattypeunique = 2,
      repeattypeapplymacro = 3
   };

◆ TextualCommandResult

enum CommandManager::TextualCommandResult

Enumerator
CommandFailure
CommandSuccess
CommandNotFound

Definition at line 244 of file CommandManager.h.

                             {
      CommandFailure,
      CommandSuccess,
      CommandNotFound
   };

Constructor & Destructor Documentation

◆ CommandManager() [1/2]

CommandManager::CommandManager ( AudacityProject & project )

explicit

Standard Constructor

Definition at line 123 of file CommandManager.cpp.

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

References mLastProcessId, and UpdatePrefs().

Here is the call graph for this function:

◆ CommandManager() [2/2]

CommandManager::CommandManager ( const CommandManager & )

delete

◆ ~CommandManager()

CommandManager::~CommandManager ( )

override

Class Destructor. Includes PurgeData, which removes menubars

Definition at line 145 of file CommandManager.cpp.

{
   PurgeData();
}

References PurgeData().

Here is the call graph for this function:

Member Function Documentation

◆ Check()

void CommandManager::Check	(	const CommandID &	name,
		bool	checked
	)

Definition at line 720 of file CommandManager.cpp.

{
   if (auto iter = mCommandNameHash.find(name);
      iter != mCommandNameHash.end())
      iter->second->Check(checked);
}

References mCommandNameHash, and name.

◆ DescribeCommandsAndShortcuts()

TranslatableString CommandManager::DescribeCommandsAndShortcuts	(	const ComponentInterfaceSymbol	commands[],
		size_t	nCommands
	)		const

Formatting summaries that include shortcut keys

Definition at line 763 of file CommandManager.cpp.

{
   wxString mark;
   // This depends on the language setting and may change in-session after
   // change of preferences:
   if (BasicUI::IsUsingRtlLayout())
      mark = wxT("\u200f");
 
   static const wxString &separatorFormat = wxT("%s / %s");
   TranslatableString result;
   for (size_t ii = 0; ii < nCommands; ++ii) {
      const auto &pair = commands[ii];
      // If RTL, then the control character forces right-to-left sequencing of
      // "/" -separated command names, and puts any "(...)" shortcuts to the
      // left, consistently with accelerators in menus (assuming matching
      // operating system preferences for language), even if the command name
      // was missing from the translation file and defaulted to the English.
 
      // Note: not putting this and other short format strings in the
      // translation catalogs
      auto piece = Verbatim( wxT("%s%s") )
         .Format( mark, pair.Msgid().Stripped() );
 
      auto name = pair.Internal();
      if (!name.empty()) {
         auto keyStr = GetKeyFromName(name);
         if (!keyStr.empty()){
            auto keyString = keyStr.Display(true);
            auto format = wxT("%s %s(%s)");
#ifdef __WXMAC__
            // The unicode controls push and pop left-to-right embedding.
            // This keeps the directionally weak characters, such as uparrow
            // for Shift, left of the key name,
            // consistently with how menu accelerators appear, even when the
            // system language is RTL.
            format = wxT("%s %s(\u202a%s\u202c)");
#endif
            // The mark makes correctly placed parentheses for RTL, even
            // in the case that the piece is untranslated.
            piece = Verbatim( format ).Format( piece, mark, keyString );
         }
      }
 
      if (result.empty())
         result = piece;
      else
         result = Verbatim( separatorFormat ).Format( result, piece );
   }
   return result;
}

References TranslatableString::empty(), TranslatableString::Format(), anonymous_namespace{ExportPCM.cpp}::format, GetKeyFromName(), BasicUI::IsUsingRtlLayout(), name, Verbatim(), and wxT().

Here is the call graph for this function:

◆ DoRepeatProcess()

void CommandManager::DoRepeatProcess	(	const CommandContext &	context,
		int	id
	)

Definition at line 891 of file CommandManager.cpp.

{
   mLastProcessId = 0;  //Don't Process this as repeat
   if (auto iter = mCommandNumericIDHash.find(id);
      iter != mCommandNumericIDHash.end()
   ) {
      const auto entry = iter->second;
      // Discriminate the union entry->callback by entry->finder
      if (auto &finder = entry->finder) {
         auto &handler = finder(context.project);
         (handler.*(entry->callback.memberFn))(context);
      }
      else
         (entry->callback.nonMemberFn)(context);
   }
}

References entry, anonymous_namespace{Scrubbing.cpp}::finder, audacity::cloud::audiocom::anonymous_namespace{AuthorizationHandler.cpp}::handler, mCommandNumericIDHash, mLastProcessId, and CommandContext::project.

Referenced by anonymous_namespace{PluginMenus.cpp}::OnRepeatLastAnalyzer(), and anonymous_namespace{BatchProcessDialog.cpp}::OnRepeatLastTool().

Here is the caller graph for this function:

◆ Enable() [1/2]

void CommandManager::Enable	(	CommandListEntry &	entry,
		bool	enabled
	)

private

Enables or disables a menu item based on its name (not the label in the menu bar, but the name of the command.) If you give it the name of a multi-item (one that was added using AddItemList(), it will enable or disable all of them at once

Definition at line 634 of file CommandManager.cpp.

{
   entry.Enable(enabled);
   if (entry.multi) {
      for (int i = 1, ID = entry.id;
         i < entry.count;
         ++i, ID = NextIdentifier(ID)
      ) {
         // This menu item is not necessarily in the same menu, because
         // multi-items can be spread across multiple sub menus
         if (auto iter = mCommandNumericIDHash.find(ID);
             iter != mCommandNumericIDHash.end())
            iter->second->EnableMultiItem(enabled);
         else
            wxLogDebug(wxT("Warning: Menu entry with id %i not in hash"), ID);
      }
   }
}

References entry, mCommandNumericIDHash, NextIdentifier(), and wxT().

Here is the call graph for this function:

◆ Enable() [2/2]

void CommandManager::Enable	(	const wxString &	name,
		bool	enabled
	)

Definition at line 663 of file CommandManager.cpp.

{
   if (auto iter = mCommandNameHash.find(name);
      iter != mCommandNameHash.end())
      Enable(*iter->second, enabled);
   else
      wxLogDebug(wxT("Warning: Unknown command enabled: '%s'"),
                 (const wxChar*)name);
}

References Enable(), mCommandNameHash, name, and wxT().

Referenced by Enable(), EnableUsingFlags(), and ModifyUndoMenuItems().

Here is the call graph for this function:

Here is the caller graph for this function:

◆ EnableUsingFlags()

void CommandManager::EnableUsingFlags	(	CommandFlag	flags,
		CommandFlag	strictFlags
	)

Definition at line 673 of file CommandManager.cpp.

{
   // strictFlags are a subset of flags.  strictFlags represent the real
   // conditions now, but flags are the conditions that could be made true.
   // Some commands use strict flags only, refusing the chance to fix
   // conditions
   wxASSERT( (strictFlags & ~flags).none() );
 
   for(const auto &entry : mCommandList) {
      if (entry->multi && entry->index != 0)
         continue;
      if( entry->isOccult )
         continue;
 
      auto useFlags = entry->useStrictFlags ? strictFlags : flags;
 
      if (entry->flags.any()) {
         bool enable = ((useFlags & entry->flags) == entry->flags);
         Enable(*entry, enable);
      }
   }
}

References Enable(), entry, mCommandList, and none.

Referenced by UpdateMenus().

Here is the call graph for this function:

Here is the caller graph for this function:

◆ ExcludedList()

const std::vector< NormalizedKeyString > & CommandManager::ExcludedList ( )

static

Definition at line 150 of file CommandManager.cpp.

{
   static const auto list = [] {
      // These short cuts are for the max list only....
      const char *const strings[] = {
         // "Ctrl+I",
         "Ctrl+Alt+I",
         //"Ctrl+J",
         "Ctrl+Alt+J",
         "Ctrl+Alt+V",
         "Alt+X",
         "Alt+K",
         "Shift+Alt+X",
         "Shift+Alt+K",
         "Alt+L",
         "Shift+Alt+C",
         "Alt+I",
         "Alt+J",
         "Shift+Alt+J",
         "Ctrl+Shift+A",
         //"Q",
         //"Shift+J",
         //"Shift+K",
         //"Shift+Home",
         //"Shift+End",
         "Ctrl+[",
         "Ctrl+]",
         "1",
         "Shift+F5",
         "Shift+F6",
         "Shift+F7",
         "Shift+F8",
         "Ctrl+Shift+F5",
         "Ctrl+Shift+F7",
         "Ctrl+Shift+N",
         "Ctrl+Shift+M",
         "Ctrl+Home",
         "Ctrl+End",
         "Shift+C",
         "Alt+Shift+Up",
         "Alt+Shift+Down",
         "Shift+P",
         "Alt+Shift+Left",
         "Alt+Shift+Right",
         "Ctrl+Shift+T",
         //"Command+M",
         //"Option+Command+M",
         "Shift+H",
         "Shift+O",
         "Shift+I",
         "Shift+N",
         "D",
         "A",
         "Alt+Shift+F6",
         "Alt+F6",
      };
 
      std::vector<NormalizedKeyString> result(
         std::begin(strings), std::end(strings)
      );
      std::sort( result.begin(), result.end() );
      return result;
   }();
   return list;
}

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

Referenced by KeyConfigPrefs::FilterKeys(), and CommandManager::Populator::SetMaxList().

Here is the call graph for this function:

Here is the caller graph for this function:

◆ ExecuteCommand()

void CommandManager::ExecuteCommand	(	const CommandContext &	context,
		const wxEvent *	evt,
		const CommandListEntry &	entry
	)

protectedvirtual

Reimplemented in MenuCreator.

Definition at line 853 of file CommandManager.cpp.

{
   // Discriminate the union entry->callback by entry->finder
   if (auto &finder = entry.finder) {
      auto &handler = finder(mProject);
      (handler.*(entry.callback.memberFn))(context);
   }
   else
      (entry.callback.nonMemberFn)(context);
   mLastProcessId = 0;
}

References entry, anonymous_namespace{Scrubbing.cpp}::finder, audacity::cloud::audiocom::anonymous_namespace{AuthorizationHandler.cpp}::handler, mLastProcessId, and mProject.

Referenced by MenuCreator::ExecuteCommand(), and HandleCommandEntry().

Here is the caller graph for this function:

◆ FormatLabelForMenu()

wxString CommandManager::FormatLabelForMenu	(	const CommandID &	id,
		const TranslatableString *	pLabel
	)		const

Format a string appropriate for insertion in a menu.

Parameters

pLabel if not null, use this instead of the manager's stored label

Definition at line 598 of file CommandManager.cpp.

{
   NormalizedKeyString keyStr;
   if (auto iter = mCommandNameHash.find(id); iter != mCommandNameHash.end()) {
      if (auto pEntry = iter->second) {
         keyStr = pEntry->key;
         if (!pLabel)
            pLabel = &pEntry->label;
      }
   }
   if (pLabel)
      return CommandListEntry::FormatLabelForMenu(*pLabel, keyStr);
   return {};
}

References CommandManager::CommandListEntry::FormatLabelForMenu(), and mCommandNameHash.

Here is the call graph for this function:

◆ Get() [1/2]

CommandManager & CommandManager::Get ( AudacityProject & project )

static

Definition at line 110 of file CommandManager.cpp.

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

References key, and project.

◆ Get() [2/2]

const CommandManager & CommandManager::Get ( const AudacityProject & project )

static

Definition at line 115 of file CommandManager.cpp.

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

References Get(), and project.

Here is the call graph for this function:

◆ GetAllCommandData()

void CommandManager::GetAllCommandData	(	CommandIDs &	names,
		std::vector< NormalizedKeyString > &	keys,
		std::vector< NormalizedKeyString > &	default_keys,
		TranslatableStrings &	labels,
		TranslatableStrings &	categories,
		TranslatableStrings &	prefixes,
		bool	includeMultis
	)

Definition at line 1037 of file CommandManager.cpp.

{
   for(const auto &entry : mCommandList) {
      // GetAllCommandData is used by KeyConfigPrefs.
      // It does need the effects.
      //if ( entry->isEffect )
      //   continue;
      if ( !entry->multi || includeMultis )
      {
         names.push_back(entry->name);
         keys.push_back(entry->key);
         default_keys.push_back(entry->defaultKey);
         labels.push_back(entry->label);
         categories.push_back(entry->labelTop);
         prefixes.push_back(entry->labelPrefix);
      }
   }
}

References entry, mCommandList, and names.

Referenced by KeyConfigPrefs::RefreshBindings().

Here is the caller graph for this function:

◆ GetAllCommandLabels()

void CommandManager::GetAllCommandLabels	(	TranslatableStrings &	labels,
		std::vector< bool > &	vExcludeFromMacros,
		bool	includeMultis
	)		const

Definition at line 1018 of file CommandManager.cpp.

{
   vExcludeFromMacros.clear();
   for(const auto &entry : mCommandList) {
      // This is fetching commands from the menus, for use as batch commands.
      // Until we have properly merged EffectManager and CommandManager
      // we explicitly exclude effects, as they are already handled by the
      // effects Manager.
      if ( entry->isEffect )
         continue;
      if (!entry->multi)
         names.push_back(entry->longLabel), vExcludeFromMacros.push_back(entry->excludeFromMacros);
      else if( includeMultis )
         names.push_back(entry->longLabel), vExcludeFromMacros.push_back(entry->excludeFromMacros);
   }
}

References entry, mCommandList, and names.

◆ GetAllCommandNames()

void CommandManager::GetAllCommandNames	(	CommandIDs &	names,
		bool	includeMultis
	)		const

Definition at line 1005 of file CommandManager.cpp.

{
   for(const auto &entry : mCommandList) {
      if ( entry->isEffect )
         continue;
      if (!entry->multi)
         names.push_back(entry->name);
      else if( includeMultis )
         names.push_back(entry->name );// + wxT(":")/*+ mCommandList[i]->label*/);
   }
}

References entry, mCommandList, and names.

◆ GetCategories()

TranslatableStrings CommandManager::GetCategories ( )

Definition at line 973 of file CommandManager.cpp.

{
   TranslatableStrings cats;
 
   for (const auto &entry : mCommandList) {
      auto &cat = entry->labelTop;
      if ( ! make_iterator_range( cats ).contains(cat) ) {
         cats.push_back(cat);
      }
   }
#if 0
   mCommandList.size(); i++) {
      if (includeMultis || !mCommandList[i]->multi)
         names.push_back(mCommandList[i]->name);
   }
 
   if (p == NULL) {
      return;
   }
 
   wxMenuBar *bar = p->GetMenuBar();
   size_t cnt = bar->GetMenuCount();
   for (size_t i = 0; i < cnt; i++) {
      cats.push_back(bar->GetMenuLabelText(i));
   }
 
   cats.push_back(COMMAND);
#endif
 
   return cats;
}

References COMMAND, entry, make_iterator_range(), mCommandList, name, and names.

Here is the call graph for this function:

◆ GetCategoryFromName()

TranslatableString CommandManager::GetCategoryFromName ( const CommandID & name ) const

Definition at line 1097 of file CommandManager.cpp.

{
   if (auto iter = mCommandNameHash.find(name);
      iter != mCommandNameHash.end())
      return iter->second->labelTop;
   return {};
}

References mCommandNameHash, and name.

Referenced by KeyConfigPrefs::OnSet().

Here is the caller graph for this function:

◆ GetDefaultKeyFromName()

NormalizedKeyString CommandManager::GetDefaultKeyFromName ( const CommandID & name ) const

Definition at line 1113 of file CommandManager.cpp.

{
   if (auto iter = mCommandNameHash.find(name);
      iter != mCommandNameHash.end())
      return iter->second->defaultKey;
   return {};
}

References mCommandNameHash, and name.

Referenced by KeyConfigPrefs::OnSet().

Here is the caller graph for this function:

◆ GetEnabled()

bool CommandManager::GetEnabled ( const CommandID & name ) const

Definition at line 697 of file CommandManager.cpp.

{
   if (auto iter = mCommandNameHash.find(name);
      iter != mCommandNameHash.end())
      return iter->second->GetEnabled();
   else {
      // using GET in a log message for devs' eyes only
      wxLogDebug(wxT("Warning: command doesn't exist: '%s'"),
                 name.GET());
      return false;
   }
}

References mCommandNameHash, name, and wxT().

Referenced by ToolBarButtons::ForAllButtons().

Here is the call graph for this function:

Here is the caller graph for this function:

◆ GetKeyFromName()

NormalizedKeyString CommandManager::GetKeyFromName ( const CommandID & name ) const

Definition at line 1105 of file CommandManager.cpp.

{
   if (auto iter = mCommandNameHash.find(name);
      iter != mCommandNameHash.end())
      return iter->second->key;
   return {};
}

References mCommandNameHash, and name.

Referenced by DescribeCommandsAndShortcuts(), KeyConfigPrefs::MergeWithExistingKeys(), SelectHandle::Preview(), and KeyConfigPrefs::RefreshKeyInfo().

Here is the caller graph for this function:

◆ GetLabelFromName()

TranslatableString CommandManager::GetLabelFromName ( const CommandID & name ) const

Definition at line 1071 of file CommandManager.cpp.

{
   if (auto iter = mCommandNameHash.find(name);
      iter != mCommandNameHash.end())
      return iter->second->longLabel;
   return {};
}

References mCommandNameHash, and name.

◆ GetNameFromNumericID()

CommandID CommandManager::GetNameFromNumericID ( int id ) const

Definition at line 1063 of file CommandManager.cpp.

{
   if (auto iter = mCommandNumericIDHash.find(id);
      iter != mCommandNumericIDHash.end())
      return iter->second->name;
   return {};
}

References mCommandNumericIDHash.

◆ GetNumberOfKeysRead()

int CommandManager::GetNumberOfKeysRead ( ) const

Definition at line 715 of file CommandManager.cpp.

{
   return mXMLKeysRead;
}

References mXMLKeysRead.

Referenced by KeyConfigPrefs::OnImport().

Here is the caller graph for this function:

◆ GetPrefixedLabelFromName()

TranslatableString CommandManager::GetPrefixedLabelFromName ( const CommandID & name ) const

Definition at line 1080 of file CommandManager.cpp.

{
   if (auto iter = mCommandNameHash.find(name);
      iter != mCommandNameHash.end()
   ) {
      const auto entry = iter->second;
      if (!entry->labelPrefix.empty())
         return Verbatim( wxT("%s - %s") )
            .Format(entry->labelPrefix, entry->label)
               .Stripped();
      else
         return entry->label.Stripped();
   }
   return {};
}

References entry, TranslatableString::Format(), mCommandNameHash, name, TranslatableString::Stripped(), Verbatim(), and wxT().

Referenced by KeyConfigPrefs::ContainsIllegalDups(), KeyConfigPrefs::MergeWithExistingKeys(), and KeyConfigPrefs::OnSet().

Here is the call graph for this function:

Here is the caller graph for this function:

◆ GetProject()

AudacityProject & CommandManager::GetProject ( )

inline

Definition at line 117 of file CommandManager.h.

117{ return mProject; }

Referenced by HandleTextualCommand().

Here is the caller graph for this function:

◆ GetUpdateFlags()

CommandFlag CommandManager::GetUpdateFlags ( bool quick = false ) const

Definition at line 1281 of file CommandManager.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 (quick)
      // 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 mProject, ReservedCommandFlag::Options(), and ReservedCommandFlag::RegisteredPredicates().

Referenced by 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:

◆ HandleCommandEntry()

bool CommandManager::HandleCommandEntry	(	const CommandListEntry *	entry,
		CommandFlag	flags,
		bool	alwaysEnabled,
		const wxEvent *	evt = `nullptr`,
		const CommandContext *	pGivenContext = `nullptr`
	)

protected

HandleCommandEntry() takes a CommandListEntry and executes it returning true iff successful. If you pass any flags, the command won't be executed unless the flags are compatible with the command's flags.

Definition at line 819 of file CommandManager.cpp.

{
   if (!entry )
      return false;
 
   if (flags != AlwaysEnabledFlag && !entry->enabled)
      return false;
 
   if (!alwaysEnabled && entry->flags.any()) {
 
      const auto NiceName = entry->label.Stripped(
         TranslatableString::Ellipses | TranslatableString::MenuCodes );
      // NB: The call may have the side effect of changing flags.
      bool allowed = ReportIfActionNotAllowed(NiceName, flags, entry->flags);
      // If the function was disallowed, it STILL should count as having been
      // handled (by doing nothing or by telling the user of the problem).
      // Otherwise we may get other handlers having a go at obeying the command.
      if (!allowed)
         return true;
      mNiceName = NiceName;
   }
   else {
      mNiceName = {};
   }
 
   CommandContext context{ mProject, evt, entry->index, entry->parameter };
   if (pGivenContext)
      context.temporarySelection = pGivenContext->temporarySelection;
   ExecuteCommand(context, evt, *entry);
   return true;
}

References AlwaysEnabledFlag, TranslatableString::Ellipses, entry, ExecuteCommand(), TranslatableString::MenuCodes, mNiceName, mProject, ReportIfActionNotAllowed(), and CommandContext::temporarySelection.

Referenced by HandleMenuID(), and HandleTextualCommand().

Here is the call graph for this function:

Here is the caller graph for this function:

◆ HandleMenuID()

bool CommandManager::HandleMenuID	(	int	id,
		CommandFlag	flags,
		bool	alwaysEnabled
	)

Call this when a menu event is received. If it matches a command, it will call the appropriate CommandManagerListener function. If you pass any flags, the command won't be executed unless the flags are compatible with the command's flags.

Definition at line 914 of file CommandManager.cpp.

{
   mLastProcessId = id;
   if (auto iter = mCommandNumericIDHash.find(id);
      iter != mCommandNumericIDHash.end()
   ) {
      const auto entry = iter->second;
      if (GlobalMenuHook::Call(entry->name))
         return true;
 
      return HandleCommandEntry(entry, flags, alwaysEnabled);
   }
   return false;
}

References GlobalHook< GlobalMenuHook, bool(const CommandID &) >::Call(), entry, HandleCommandEntry(), id, mCommandNumericIDHash, and mLastProcessId.

Here is the call graph for this function:

◆ HandleTextualCommand()

CommandManager::TextualCommandResult CommandManager::HandleTextualCommand	(	const CommandID &	Str,
		const CommandContext &	context,
		CommandFlag	flags,
		bool	alwaysEnabled
	)

Precondition: &context.project == &GetProject()

HandleTextualCommand() allows us a limited version of script/batch behavior, since we can get from a string command name to the actual code to run.

Definition at line 934 of file CommandManager.cpp.

{
   assert(&context.project == &GetProject());
   if( Str.empty() )
      return CommandFailure;
   // Linear search for now...
   for (const auto &entry : mCommandList)
   {
      if (!entry->multi)
      {
         // Testing against labelPrefix too allows us to call Nyquist functions by name.
         if( Str == entry->name ||
            // PRL:  uh oh, mixing internal string (Str) with user-visible
            // (labelPrefix, which was initialized from a user-visible
            // sub-menu name)
            Str == entry->labelPrefix.Translation() )
         {
            return HandleCommandEntry(
               entry.get(), flags, alwaysEnabled,
               nullptr, &context)
               ? CommandSuccess : CommandFailure;
         }
      }
      else
      {
         // Handle multis too...
         if( Str == entry->name )
         {
            return HandleCommandEntry(
               entry.get(), flags, alwaysEnabled,
               nullptr, &context)
               ? CommandSuccess : CommandFailure;
         }
      }
   }
   return CommandNotFound;
}

References CommandFailure, CommandNotFound, CommandSuccess, Identifier::empty(), entry, GetProject(), HandleCommandEntry(), mCommandList, and CommandContext::project.

Here is the call graph for this function:

◆ HandleXMLChild()

XMLTagHandler * CommandManager::HandleXMLChild ( const std::string_view & tag )

overrideprivatevirtual

Implements XMLTagHandler.

Definition at line 1173 of file CommandManager.cpp.

{
   return this;
}

◆ HandleXMLEndTag()

void CommandManager::HandleXMLEndTag ( const std::string_view & tag )

overrideprivate

Definition at line 1160 of file CommandManager.cpp.

{
   /*
   if (tag == "audacitykeyboard") {
      AudacityMessageBox(
         XO("Loaded %d keyboard shortcuts\n")
            .Format( mXMLKeysRead ),
         XO("Loading Keyboard Shortcuts"),
         wxOK | wxCENTRE);
   }
   */
}

◆ HandleXMLTag()

bool CommandManager::HandleXMLTag	(	const std::string_view &	tag,
		const AttributesList &	attrs
	)

overrideprivatevirtual

Implements XMLTagHandler.

Definition at line 1122 of file CommandManager.cpp.

{
   if (tag == "audacitykeyboard") {
      mXMLKeysRead = 0;
   }
 
   if (tag == "command") {
      wxString name;
      NormalizedKeyString key;
 
      for (auto pair : attrs)
      {
         auto attr = pair.first;
         auto value = pair.second;
 
         if (value.IsStringView())
         {
            const wxString strValue = value.ToWString();
 
            if (attr == "name")
               name = strValue;
            else if (attr == "key")
               key = NormalizedKeyString{ strValue };
         }
      }
 
      if (auto iter = mCommandNameHash.find(name);
         iter != mCommandNameHash.end()
      ) {
         iter->second->key = key;
         ++mXMLKeysRead;
      }
   }
 
   return true;
}

References key, mCommandNameHash, mXMLKeysRead, and name.

◆ Modify()

void CommandManager::Modify	(	const wxString &	name,
		const TranslatableString &	newLabel
	)

Changes the label text of a menu item.

Definition at line 732 of file CommandManager.cpp.

{
   if (auto iter = mCommandNameHash.find(name);
      iter != mCommandNameHash.end())
      iter->second->Modify(newLabel);
}

References mCommandNameHash, and name.

Referenced by ModifyUndoMenuItems(), RegisterLastAnalyzer(), and RegisterLastTool().

Here is the caller graph for this function:

◆ ModifyUndoMenuItems()

void CommandManager::ModifyUndoMenuItems ( )

Definition at line 1438 of file CommandManager.cpp.

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

References anonymous_namespace{ExportPCM.cpp}::desc, Enable(), ProjectHistory::Get(), UndoManager::Get(), Modify(), mProject, 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:

◆ NCommands()

size_t CommandManager::NCommands ( ) const

inline

Definition at line 118 of file CommandManager.h.

118{ return mCommandList.size(); }

Referenced by SetKeyFromIndex().

Here is the caller graph for this function:

◆ NextIdentifier()

int CommandManager::NextIdentifier ( int ID )

staticprivate

Definition at line 429 of file CommandManager.cpp.

{
   ID++;
 
   //Skip the reserved identifiers used by wxWidgets
   if((ID >= wxID_LOWEST) && (ID <= wxID_HIGHEST))
      ID = wxID_HIGHEST+1;
 
   return ID;
}

Referenced by Enable(), and CommandManager::Populator::NewIdentifier().

Here is the caller graph for this function:

◆ OnUndoRedo()

void CommandManager::OnUndoRedo ( struct UndoRedoMessage message )

private

Definition at line 1465 of file CommandManager.cpp.

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

References ModifyUndoMenuItems(), UndoRedoMessage::Pushed, UndoRedoMessage::Renamed, UndoRedoMessage::Reset, UndoRedoMessage::type, UndoRedoMessage::UndoOrRedo, and UpdateMenus().

Here is the call graph for this function:

◆ operator=()

CommandManager & CommandManager::operator= ( const CommandManager & )

delete

◆ PurgeData()

void CommandManager::PurgeData ( )

Definition at line 238 of file CommandManager.cpp.

{
   // mCommandList contains unique pointers to CommandListEntrys
   mCommandList.clear();
 
   // Then clear the three hashes of dangling pointers
   mCommandNameHash.clear();
   mCommandKeyHash.clear();
   mCommandNumericIDHash.clear();
}

References mCommandKeyHash, mCommandList, mCommandNameHash, and mCommandNumericIDHash.

Referenced by MenuCreator::RebuildMenuBar(), and ~CommandManager().

Here is the caller graph for this function:

◆ ReallyDoQuickCheck()

bool CommandManager::ReallyDoQuickCheck ( )

protectedvirtual

Default implementation returns true.

Reimplemented in MenuCreator.

Definition at line 1521 of file CommandManager.cpp.

{
   return true;
}

Referenced by UpdateMenus().

Here is the caller graph for this function:

◆ RegisterLastAnalyzer()

void CommandManager::RegisterLastAnalyzer ( const CommandContext & context )

Definition at line 868 of file CommandManager.cpp.

                                                                       {
   if (mLastProcessId != 0) {
      mLastAnalyzerRegistration = repeattypeunique;
      mLastAnalyzerRegisteredId = mLastProcessId;
      auto lastEffectDesc = XO("Repeat %s").Format(mNiceName);
      Modify(wxT("RepeatLastAnalyzer"), lastEffectDesc);
   }
   return;
}

References mLastAnalyzerRegisteredId, mLastAnalyzerRegistration, mLastProcessId, mNiceName, Modify(), repeattypeunique, wxT(), and XO().

Referenced by anonymous_namespace{Contrast.cpp}::anonymous_namespace{Contrast.cpp}::OnContrast(), and anonymous_namespace{FreqWindow.cpp}::OnPlotSpectrum().

Here is the call graph for this function:

Here is the caller graph for this function:

◆ RegisterLastTool()

void CommandManager::RegisterLastTool ( const CommandContext & context )

Definition at line 880 of file CommandManager.cpp.

                                                                   {
   if (mLastProcessId != 0) {
      mLastToolRegistration = repeattypeunique;
      mLastToolRegisteredId = mLastProcessId;
      auto lastEffectDesc = XO("Repeat %s").Format(mNiceName);
      Modify(wxT("RepeatLastTool"), lastEffectDesc);
   }
   return;
}

References mLastProcessId, mLastToolRegisteredId, mLastToolRegistration, mNiceName, Modify(), repeattypeunique, wxT(), and XO().

Referenced by anonymous_namespace{BatchProcessDialog.cpp}::OnApplyMacrosPalette(), anonymous_namespace{PluginMenus.cpp}::OnBenchmark(), and anonymous_namespace{BatchProcessDialog.cpp}::OnManageMacros().

Here is the call graph for this function:

Here is the caller graph for this function:

◆ ReportDuplicateShortcuts()

TranslatableString CommandManager::ReportDuplicateShortcuts ( )

Definition at line 1257 of file CommandManager.cpp.

{
   TranslatableString disabledShortcuts;
 
   for (auto& entry : mCommandList) {
      if (!entry->key.empty() && entry->key != entry->defaultKey) {  // user assigned
         for (auto& entry2 : mCommandList) {
            if (!entry2->key.empty() && entry2->key == entry2->defaultKey) { // default
               if (entry2->key == entry->key) {
                  auto name = wxT("/NewKeys/") + entry2->name.GET();
                  gPrefs->Write(name, NormalizedKeyString{});
 
                  disabledShortcuts +=
                     XO("\n* %s, because you have assigned the shortcut %s to %s")
                     .Format(entry2->label.Strip(), entry->key.GET(), entry->label.Strip());
               }
            }
         }
      }
   }
 
   return disabledShortcuts;
}

References entry, gPrefs, mCommandList, name, audacity::BasicSettings::Write(), wxT(), and XO().

Referenced by MenuCreator::RemoveDuplicateShortcuts().

Here is the call graph for this function:

Here is the caller graph for this function:

◆ ReportIfActionNotAllowed()

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

Definition at line 1321 of file CommandManager.cpp.

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

References mProject, project, TellUserWhyDisallowed(), and TryToMakeActionAllowed().

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

Here is the call graph for this function:

Here is the caller graph for this function:

◆ SetCommandFlags()

void CommandManager::SetCommandFlags	(	const CommandID &	name,
		CommandFlag	flags
	)

Definition at line 1203 of file CommandManager.cpp.

{
   if (auto iter = mCommandNameHash.find(name);
      iter != mCommandNameHash.end())
      iter->second->flags = flags;
}

References mCommandNameHash, and name.

Referenced by CommandManager::Populator::AddItem().

Here is the caller graph for this function:

◆ SetKeyFromIndex()

void CommandManager::SetKeyFromIndex	(	int	i,
		const NormalizedKeyString &	key
	)

Precondition: 0 <= i && i < NCommands()

Definition at line 753 of file CommandManager.cpp.

{
   if (!(0 <= i && i < NCommands())) {
      assert(false);
      return;
   }
   const auto &entry = mCommandList[i];
   entry->key = key;
}

References entry, key, mCommandList, and NCommands().

Referenced by KeyConfigPrefs::Cancel(), KeyConfigPrefs::MergeWithExistingKeys(), and KeyConfigPrefs::OnImportDefaults().

Here is the call graph for this function:

Here is the caller graph for this function:

◆ SetKeyFromName()

void CommandManager::SetKeyFromName	(	const CommandID &	name,
		const NormalizedKeyString &	key
	)

Definition at line 745 of file CommandManager.cpp.

{
   if (auto iter = mCommandNameHash.find(name);
      iter != mCommandNameHash.end())
      iter->second->key = key;
}

References key, mCommandNameHash, and name.

Referenced by KeyConfigPrefs::ClearAllKeys(), KeyConfigPrefs::OnImport(), KeyConfigPrefs::OnSet(), and KeyConfigPrefs::SetKeyForSelected().

Here is the caller graph for this function:

◆ TellUserWhyDisallowed()

void CommandManager::TellUserWhyDisallowed	(	const TranslatableString &	Name,
		CommandFlag	flagsGot,
		CommandFlag	flagsRequired
	)

private

Definition at line 1366 of file CommandManager.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 CommandManager::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 1335 of file CommandManager.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(), details::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:

◆ UpdateCheckmarks()

void CommandManager::UpdateCheckmarks ( )

Definition at line 339 of file CommandManager.cpp.

{
   for (const auto &entry : mCommandList)
      entry->UpdateCheckmark(mProject);
}

References entry, mCommandList, and mProject.

Referenced by SelectUtilities::ActivatePlayRegion(), SelectUtilities::InactivatePlayRegion(), ToolManager::ModifyToolbarMenus(), and anonymous_namespace{TimelineMenus.cpp}::SetTimeDisplayMode().

Here is the caller graph for this function:

◆ UpdateMenus()

void CommandManager::UpdateMenus ( bool checkActive = true )

Definition at line 1482 of file CommandManager.cpp.

{
   auto &project = mProject;
 
   bool quick = checkActive && ReallyDoQuickCheck();
   auto flags = GetUpdateFlags(quick);
   // 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();
   }
 
   // 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.
   EnableUsingFlags(
      flags2, // the "lax" flags
      (mWhatIfNoSelection == 0 ? flags2 : flags) // the "strict" flags
   );
 
   Publish({});
}

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

Referenced by MacroCommands::ApplyCommandInBatchMode(), AudacityApplicationLogic::DoEffect(), OnUndoRedo(), ProjectWindow::OnUpdateUI(), and ProjectWindow::OnViewportMessage().

Here is the call graph for this function:

Here is the caller graph for this function:

◆ UpdatePrefs()

void CommandManager::UpdatePrefs ( )

overridevirtual

Implements PrefsListener.

Definition at line 133 of file CommandManager.cpp.

{
   bool bSelectAllIfNone;
   gPrefs->Read(wxT("/GUI/SelectAllOnNone"), &bSelectAllIfNone, false);
   // 0 is grey out, 1 is Autoselect, 2 is Give warnings.
   // Audacity autoselects or warns.
   mWhatIfNoSelection = bSelectAllIfNone ? 1 : 2;
}

References gPrefs, mWhatIfNoSelection, audacity::BasicSettings::Read(), and wxT().

Referenced by CommandManager().

Here is the call graph for this function:

Here is the caller graph for this function:

◆ WriteXML()

void CommandManager::WriteXML ( XMLWriter & xmlFile ) const

Definition at line 1178 of file CommandManager.cpp.

{
   xmlFile.StartTag(wxT("audacitykeyboard"));
   xmlFile.WriteAttr(wxT("audacityversion"), AUDACITY_VERSION_STRING);
 
   for(const auto &entry : mCommandList) {
 
      xmlFile.StartTag(wxT("command"));
      xmlFile.WriteAttr(wxT("name"), entry->name);
      xmlFile.WriteAttr(wxT("key"), entry->key);
      xmlFile.EndTag(wxT("command"));
   }
 
   xmlFile.EndTag(wxT("audacitykeyboard"));
}

References entry, mCommandList, and wxT().

Referenced by KeyConfigPrefs::OnExport().

Here is the call graph for this function:

Here is the caller graph for this function:

Member Data Documentation

◆ COMMAND

const TranslatableString CommandManager::COMMAND = XO("Command")

staticprotected

Definition at line 56 of file CommandManager.h.

Referenced by GetCategories().

◆ mCommandKeyHash

CommandKeyHash CommandManager::mCommandKeyHash

protected

Invariant: for each [key, value]: for some 0 <= i < NCommands(): value == mCommandList[i].get()

Definition at line 435 of file CommandManager.h.

Referenced by PurgeData().

◆ mCommandList

CommandList CommandManager::mCommandList

private

Invariant: for all 0 <= i < NCommands(): mCommandList[i] != nullptr

Definition at line 443 of file CommandManager.h.

Referenced by EnableUsingFlags(), GetAllCommandData(), GetAllCommandLabels(), GetAllCommandNames(), GetCategories(), HandleTextualCommand(), PurgeData(), ReportDuplicateShortcuts(), SetKeyFromIndex(), UpdateCheckmarks(), and WriteXML().

◆ mCommandNameHash

CommandNameHash CommandManager::mCommandNameHash

private

Invariant: for each [key, value]: for some 0 <= i < NCommands(): value == mCommandList[i].get()

Definition at line 448 of file CommandManager.h.

Referenced by Check(), Enable(), FormatLabelForMenu(), GetCategoryFromName(), GetDefaultKeyFromName(), GetEnabled(), GetKeyFromName(), GetLabelFromName(), GetPrefixedLabelFromName(), HandleXMLTag(), Modify(), PurgeData(), SetCommandFlags(), and SetKeyFromName().

◆ mCommandNumericIDHash

CommandNumericIDHash CommandManager::mCommandNumericIDHash

private

Invariant: for each [key, value]: for some 0 <= i < NCommands(): value == mCommandList[i].get()

Definition at line 453 of file CommandManager.h.

Referenced by DoRepeatProcess(), Enable(), GetNameFromNumericID(), HandleMenuID(), and PurgeData().

◆ mLastAnalyzer

PluginID CommandManager::mLastAnalyzer {}

Definition at line 94 of file CommandManager.h.

Referenced by anonymous_namespace{PluginMenus.cpp}::AnalyzeMenu(), and anonymous_namespace{PluginMenus.cpp}::HasLastAnalyzerFlag().

◆ mLastAnalyzerRegisteredId

int CommandManager::mLastAnalyzerRegisteredId = -1

Definition at line 96 of file CommandManager.h.

Referenced by RegisterLastAnalyzer().

◆ mLastAnalyzerRegistration

int CommandManager::mLastAnalyzerRegistration = repeattypenone

Definition at line 95 of file CommandManager.h.

Referenced by anonymous_namespace{PluginMenus.cpp}::HasLastAnalyzerFlag(), and RegisterLastAnalyzer().

◆ mLastEffect

PluginID CommandManager::mLastEffect {}

Definition at line 93 of file CommandManager.h.

Referenced by anonymous_namespace{PluginMenus.cpp}::EffectMenu(), and anonymous_namespace{PluginMenus.cpp}::HasLastEffectFlag().

◆ mLastFlags

CommandFlag CommandManager::mLastFlags = AlwaysEnabledFlag

Definition at line 89 of file CommandManager.h.

Referenced by MenuCreator::CreateMenusAndCommands(), and UpdateMenus().

◆ mLastGenerator

PluginID CommandManager::mLastGenerator {}

Definition at line 92 of file CommandManager.h.

Referenced by anonymous_namespace{PluginMenus.cpp}::GenerateMenu(), and anonymous_namespace{PluginMenus.cpp}::HasLastGeneratorFlag().

◆ mLastProcessId

int CommandManager::mLastProcessId

private

Definition at line 457 of file CommandManager.h.

Referenced by CommandManager(), DoRepeatProcess(), ExecuteCommand(), HandleMenuID(), RegisterLastAnalyzer(), and RegisterLastTool().

◆ mLastTool

PluginID CommandManager::mLastTool {}

Definition at line 97 of file CommandManager.h.

Referenced by PluginMenuItems().

◆ mLastToolRegisteredId

int CommandManager::mLastToolRegisteredId = -1

Definition at line 99 of file CommandManager.h.

Referenced by RegisterLastTool().

◆ mLastToolRegistration

int CommandManager::mLastToolRegistration = repeattypenone

Definition at line 98 of file CommandManager.h.

Referenced by RegisterLastTool().

◆ mNiceName

TranslatableString CommandManager::mNiceName

private

Definition at line 456 of file CommandManager.h.

Referenced by HandleCommandEntry(), RegisterLastAnalyzer(), and RegisterLastTool().

◆ mProject

AudacityProject& CommandManager::mProject

protected

Definition at line 371 of file CommandManager.h.

Referenced by CommandManager::Populator::AddItem(), MenuCreator::CreateMenusAndCommands(), ExecuteCommand(), GetUpdateFlags(), HandleCommandEntry(), ModifyUndoMenuItems(), CommandManager::Populator::NewIdentifier(), MenuCreator::ReallyDoQuickCheck(), MenuCreator::RebuildMenuBar(), ReportIfActionNotAllowed(), TryToMakeActionAllowed(), UpdateCheckmarks(), and UpdateMenus().

◆ mRepeatAnalyzerFlags

unsigned CommandManager::mRepeatAnalyzerFlags = 0

Definition at line 108 of file CommandManager.h.

◆ mRepeatEffectFlags

unsigned CommandManager::mRepeatEffectFlags = 0

Definition at line 107 of file CommandManager.h.

◆ mRepeatGeneratorFlags

unsigned CommandManager::mRepeatGeneratorFlags = 0

Definition at line 106 of file CommandManager.h.

◆ mRepeatToolFlags

unsigned CommandManager::mRepeatToolFlags = 0

Definition at line 109 of file CommandManager.h.

◆ mStopIfWasPaused

bool CommandManager::mStopIfWasPaused { true }

Definition at line 115 of file CommandManager.h.

◆ mUndoSubscription

const Observer::Subscription CommandManager::mUndoSubscription

private

Definition at line 459 of file CommandManager.h.

◆ mWhatIfNoSelection

int CommandManager::mWhatIfNoSelection

Definition at line 112 of file CommandManager.h.

Referenced by UpdateMenus(), and UpdatePrefs().

◆ mXMLKeysRead

int CommandManager::mXMLKeysRead

private

Definition at line 454 of file CommandManager.h.

Referenced by GetNumberOfKeysRead(), and HandleXMLTag().

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

Classes

Public Types

Public Member Functions

Static Public Member Functions

Public Attributes

Protected Types

Protected Member Functions

Protected Attributes

Static Protected Attributes

Private Types

Private Member Functions

Static Private Member Functions

Private Attributes

Additional Inherited Members

Detailed Description

Member Typedef Documentation

◆ CommandKeyHash

◆ CommandList

◆ CommandNameHash

◆ CommandNumericIDHash

Member Enumeration Documentation

◆ anonymous enum

◆ TextualCommandResult

Constructor & Destructor Documentation

◆ CommandManager() [1/2]

◆ CommandManager() [2/2]

◆ ~CommandManager()

Member Function Documentation

◆ Check()

◆ DescribeCommandsAndShortcuts()

◆ DoRepeatProcess()

◆ Enable() [1/2]

◆ Enable() [2/2]

◆ EnableUsingFlags()

◆ ExcludedList()

◆ ExecuteCommand()

◆ FormatLabelForMenu()

◆ Get() [1/2]

◆ Get() [2/2]

◆ GetAllCommandData()

◆ GetAllCommandLabels()

◆ GetAllCommandNames()

◆ GetCategories()

◆ GetCategoryFromName()

◆ GetDefaultKeyFromName()

◆ GetEnabled()

◆ GetKeyFromName()

◆ GetLabelFromName()

◆ GetNameFromNumericID()

◆ GetNumberOfKeysRead()

◆ GetPrefixedLabelFromName()

◆ GetProject()

◆ GetUpdateFlags()

◆ HandleCommandEntry()

◆ HandleMenuID()

◆ HandleTextualCommand()

◆ HandleXMLChild()

◆ HandleXMLEndTag()

◆ HandleXMLTag()

◆ Modify()

◆ ModifyUndoMenuItems()

◆ NCommands()

◆ NextIdentifier()

◆ OnUndoRedo()

◆ operator=()

◆ PurgeData()

◆ ReallyDoQuickCheck()

◆ RegisterLastAnalyzer()

◆ RegisterLastTool()

◆ ReportDuplicateShortcuts()

◆ ReportIfActionNotAllowed()

◆ SetCommandFlags()

◆ SetKeyFromIndex()

◆ SetKeyFromName()

◆ TellUserWhyDisallowed()

◆ TryToMakeActionAllowed()

◆ UpdateCheckmarks()

◆ UpdateMenus()

◆ UpdatePrefs()

◆ WriteXML()