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

#include <CommandManager.h>

Inheritance diagram for CommandManager:

Collaboration diagram for CommandManager:

Classes
struct	GlobalMenuHook

struct	Options

Public Types
enum	TextualCommandResult { CommandFailure , CommandSuccess , CommandNotFound }

using	CheckFn = std::function< bool(AudacityProject &) >

Public Member Functions
	CommandManager ()

virtual	~CommandManager ()

	CommandManager (const CommandManager &)=delete

CommandManager &	operator= (const CommandManager &)=delete

void	SetMaxList ()

void	PurgeData ()

std::unique_ptr< wxMenuBar >	AddMenuBar (const wxString &sMenu)

wxMenu *	BeginMenu (const TranslatableString &tName)

void	EndMenu ()
	This attaches a menu, if it's main, to the menubar. More...

void	AddItemList (const CommandID &name, const ComponentInterfaceSymbol items[], size_t nItems, CommandHandlerFinder finder, CommandFunctorPointer callback, CommandFlag flags, bool bIsEffect=false)

void	AddItem (AudacityProject &project, const CommandID &name, const TranslatableString &label_in, CommandHandlerFinder finder, CommandFunctorPointer callback, CommandFlag flags, const Options &options={})

void	AddSeparator ()

void	PopMenuBar ()

void	BeginOccultCommands ()

void	EndOccultCommands ()

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	FilterKeyEvent (AudacityProject *project, const wxKeyEvent &evt, bool permit=false)

bool	HandleMenuID (AudacityProject &project, 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 (AudacityProject &)

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, bool includeMultis)

CommandID	GetNameFromNumericID (int id)

TranslatableString	GetLabelFromName (const CommandID &name)

TranslatableString	GetPrefixedLabelFromName (const CommandID &name)

TranslatableString	GetCategoryFromName (const CommandID &name)

NormalizedKeyString	GetKeyFromName (const CommandID &name) const

NormalizedKeyString	GetDefaultKeyFromName (const CommandID &name)

bool	GetEnabled (const CommandID &name)

int	GetNumberOfKeysRead () const

void	RemoveDuplicateShortcuts ()

void	WriteXML (XMLWriter &xmlFile) const

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

wxMenu *	CurrentMenu () const

void	UpdateCheckmarks (AudacityProject &project)

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

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 ()

Static Public Member Functions
static CommandManager &	Get (AudacityProject &project)

static const CommandManager &	Get (const AudacityProject &project)

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

Private Member Functions
int	NextIdentifier (int ID)

CommandListEntry *	NewIdentifier (const CommandID &name, const TranslatableString &label, wxMenu *menu, CommandHandlerFinder finder, CommandFunctorPointer callback, const CommandID &nameSuffix, int index, int count, const Options &options)

void	AddGlobalCommand (const CommandID &name, const TranslatableString &label, CommandHandlerFinder finder, CommandFunctorPointer callback, const Options &options={})

bool	HandleCommandEntry (AudacityProject &project, const CommandListEntry entry, CommandFlag flags, bool alwaysEnabled, const wxEvent evt=nullptr, const CommandContext *pGivenContext=nullptr)

void	Enable (CommandListEntry *entry, bool enabled)

wxMenu *	BeginMainMenu (const TranslatableString &tName)

void	EndMainMenu ()

wxMenu *	BeginSubMenu (const TranslatableString &tName)

void	EndSubMenu ()

wxMenuBar *	CurrentMenuBar () const

wxMenuBar *	GetMenuBar (const wxString &sMenu) const

wxMenu *	CurrentSubMenu () const

wxString	FormatLabelForMenu (const CommandListEntry *entry) const

wxString	FormatLabelForMenu (const TranslatableString &translatableLabel, const NormalizedKeyString &keyStr) const

wxString	FormatLabelWithDisabledAccel (const CommandListEntry *entry) const

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

Private Attributes
std::vector< NormalizedKeyString >	mMaxListOnly

MenuBarList	mMenuBarList

SubMenuList	mSubMenuList

CommandList	mCommandList

CommandNameHash	mCommandNameHash

CommandKeyHash	mCommandKeyHash

CommandNumericIDHash	mCommandNumericIDHash

int	mCurrentID

int	mXMLKeysRead

bool	mbSeparatorAllowed

TranslatableString	mCurrentMenuName

TranslatableString	mNiceName

int	mLastProcessId

std::unique_ptr< wxMenu >	uCurrentMenu

wxMenu *	mCurrentMenu {}

bool	bMakingOccultCommands

std::unique_ptr< wxMenuBar >	mTempMenuBar

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 60 of file CommandManager.h.

Member Typedef Documentation

◆ CheckFn

using CommandManager::CheckFn = std::function< bool(AudacityProject&) >

Definition at line 97 of file CommandManager.h.

Member Enumeration Documentation

◆ TextualCommandResult

enum CommandManager::TextualCommandResult

Enumerator
CommandFailure
CommandSuccess
CommandNotFound

Definition at line 224 of file CommandManager.h.

                             {
      CommandFailure,
      CommandSuccess,
      CommandNotFound
   };

Constructor & Destructor Documentation

◆ CommandManager() [1/2]

CommandManager::CommandManager ( )

Standard Constructor

Definition at line 219 of file CommandManager.cpp.

                              :
   mCurrentID(17000),
   mCurrentMenuName(COMMAND),
   bMakingOccultCommands( false )
{
   mbSeparatorAllowed = false;
   SetMaxList();
   mLastProcessId = 0;
}

References mbSeparatorAllowed, mLastProcessId, and SetMaxList().

Here is the call graph for this function:

◆ ~CommandManager()

CommandManager::~CommandManager ( )

virtual

Class Destructor. Includes PurgeData, which removes menubars

Definition at line 232 of file CommandManager.cpp.

{
   //WARNING: This removes menubars that could still be assigned to windows!
   PurgeData();
}

References PurgeData().

Here is the call graph for this function:

◆ CommandManager() [2/2]

CommandManager::CommandManager ( const CommandManager & )

delete

Member Function Documentation

◆ AddGlobalCommand()

void CommandManager::AddGlobalCommand	(	const CommandID &	name,
		const TranslatableString &	label,
		CommandHandlerFinder	finder,
		CommandFunctorPointer	callback,
		const Options &	options = `{}`
	)

private

Definition at line 617 of file CommandManager.cpp.

{
   CommandListEntry *entry =
      NewIdentifier(name, label_in, NULL, finder, callback,
                    {}, 0, 0, options);
 
   entry->enabled = false;
   entry->isGlobal = true;
   entry->flags = AlwaysEnabledFlag;
}

References AlwaysEnabledFlag, entry, name, and NewIdentifier().

Referenced by AddItem().

Here is the call graph for this function:

Here is the caller graph for this function:

◆ AddItem()

void CommandManager::AddItem	(	AudacityProject &	project,
		const CommandID &	name,
		const TranslatableString &	label_in,
		CommandHandlerFinder	finder,
		CommandFunctorPointer	callback,
		CommandFlag	flags,
		const Options &	options = `{}`
	)

Definition at line 531 of file CommandManager.cpp.

{
   if (options.global) {
      //wxASSERT( flags == AlwaysEnabledFlag );
      AddGlobalCommand(
         name, label_in, finder, callback, options );
      return;
   }
 
   wxASSERT( flags != NoFlagsSpecified );
 
   CommandListEntry *entry =
      NewIdentifier(name,
         label_in,
         CurrentMenu(), finder, callback,
         {}, 0, 0,
         options);
   entry->useStrictFlags = options.useStrictFlags;
   int ID = entry->id;
   wxString label = FormatLabelWithDisabledAccel(entry);
 
   SetCommandFlags(name, flags);
 
 
   auto &checker = options.checker;
   if (checker) {
      CurrentMenu()->AppendCheckItem(ID, label);
      CurrentMenu()->Check(ID, checker( project ));
   }
   else {
      CurrentMenu()->Append(ID, label);
   }
 
   mbSeparatorAllowed = true;
}

References AddGlobalCommand(), CommandManager::Options::checker, CurrentMenu(), entry, FormatLabelWithDisabledAccel(), CommandManager::Options::global, label, mbSeparatorAllowed, name, NewIdentifier(), NoFlagsSpecified, project, SetCommandFlags(), and CommandManager::Options::useStrictFlags.

Here is the call graph for this function:

◆ AddItemList()

void CommandManager::AddItemList	(	const CommandID &	name,
		const ComponentInterfaceSymbol	items[],
		size_t	nItems,
		CommandHandlerFinder	finder,
		CommandFunctorPointer	callback,
		CommandFlag	flags,
		bool	bIsEffect = `false`
	)

Add a list of menu items to the current menu. When the user selects any one of these, the given functor will be called with its position in the list as the index number. When you call Enable on this command name, it will enable or disable all of the items at once.

Definition at line 591 of file CommandManager.cpp.

{
   for (size_t i = 0, cnt = nItems; i < cnt; i++) {
      CommandListEntry *entry =
         NewIdentifier(name,
            items[i].Msgid(),
            CurrentMenu(),
            finder,
            callback,
            items[i].Internal(),
            i,
            cnt,
            Options{}
               .IsEffect(bIsEffect));
      entry->flags = flags;
      CurrentMenu()->Append(entry->id, FormatLabelForMenu(entry));
      mbSeparatorAllowed = true;
   }
}

References CurrentMenu(), entry, FormatLabelForMenu(), Internal, CommandManager::Options::IsEffect(), mbSeparatorAllowed, name, and NewIdentifier().

Here is the call graph for this function:

◆ AddMenuBar()

std::unique_ptr< wxMenuBar > CommandManager::AddMenuBar ( const wxString & sMenu )

Makes a NEW menubar for placement on the top of a project Names it according to the passed-in string argument.

If the menubar already exists, that's unexpected.

Definition at line 350 of file CommandManager.cpp.

{
   wxMenuBar *menuBar = GetMenuBar(sMenu);
   if (menuBar) {
      wxASSERT(false);
      return {};
   }
 
   auto result = std::make_unique<wxMenuBar>();
   mMenuBarList.emplace_back(sMenu, result.get());
 
   return result;
}

References GetMenuBar(), and mMenuBarList.

Referenced by BeginOccultCommands().

Here is the call graph for this function:

Here is the caller graph for this function:

◆ AddSeparator()

void CommandManager::AddSeparator ( )

Definition at line 632 of file CommandManager.cpp.

{
   if( mbSeparatorAllowed )
      CurrentMenu()->AppendSeparator();
   mbSeparatorAllowed = false; // boolean to prevent too many separators.
}

References CurrentMenu(), and mbSeparatorAllowed.

Here is the call graph for this function:

◆ BeginMainMenu()

wxMenu * CommandManager::BeginMainMenu ( const TranslatableString & tName )

private

This starts a NEW menu

Definition at line 434 of file CommandManager.cpp.

{
   uCurrentMenu = std::make_unique<wxMenu>();
   mCurrentMenu = uCurrentMenu.get();
   mCurrentMenuName = tName;
   return mCurrentMenu;
}

References mCurrentMenu, mCurrentMenuName, and uCurrentMenu.

Referenced by BeginMenu().

Here is the caller graph for this function:

◆ BeginMenu()

wxMenu * CommandManager::BeginMenu ( const TranslatableString & tName )

This starts a NEW menu

Definition at line 409 of file CommandManager.cpp.

{
   if ( mCurrentMenu )
      return BeginSubMenu( tName );
   else
      return BeginMainMenu( tName );
}

References BeginMainMenu(), BeginSubMenu(), and mCurrentMenu.

Here is the call graph for this function:

◆ BeginOccultCommands()

void CommandManager::BeginOccultCommands ( )

Definition at line 1612 of file CommandManager.cpp.

{
   // To do:  perhaps allow occult item switching at lower levels of the
   // menu tree.
   wxASSERT( !CurrentMenu() );
 
   // Make a temporary menu bar collecting items added after.
   // This bar will be discarded but other side effects on the command
   // manager persist.
   mTempMenuBar = AddMenuBar(wxT("ext-menu"));
   bMakingOccultCommands = true;
}

References AddMenuBar(), bMakingOccultCommands, CurrentMenu(), mTempMenuBar, and wxT().

Here is the call graph for this function:

◆ BeginSubMenu()

wxMenu * CommandManager::BeginSubMenu ( const TranslatableString & tName )

private

This starts a NEW submenu, and names it according to the function's argument.

Definition at line 462 of file CommandManager.cpp.

{
   mSubMenuList.emplace_back( tName );
   mbSeparatorAllowed = false;
   return mSubMenuList.back().menu.get();
}

References mbSeparatorAllowed, and mSubMenuList.

Referenced by BeginMenu().

Here is the caller graph for this function:

◆ Check()

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

Definition at line 1009 of file CommandManager.cpp.

{
   CommandListEntry *entry = mCommandNameHash[name];
   if (!entry || !entry->menu || entry->isOccult) {
      return;
   }
   entry->menu->Check(entry->id, checked);
}

References entry, mCommandNameHash, and name.

◆ CurrentMenu()

wxMenu * CommandManager::CurrentMenu ( ) const

This returns the current menu that we're appending to - note that it could be a submenu if BeginSubMenu was called and we haven't reached EndSubMenu yet.

Definition at line 505 of file CommandManager.cpp.

{
   if(!mCurrentMenu)
      return NULL;
 
   wxMenu * tmpCurrentSubMenu = CurrentSubMenu();
 
   if(!tmpCurrentSubMenu)
   {
      return mCurrentMenu;
   }
 
   return tmpCurrentSubMenu;
}

References CurrentSubMenu(), and mCurrentMenu.

Referenced by AddItem(), AddItemList(), AddSeparator(), BeginOccultCommands(), and EndSubMenu().

Here is the call graph for this function:

Here is the caller graph for this function:

◆ CurrentMenuBar()

wxMenuBar * CommandManager::CurrentMenuBar ( ) const

private

Retrieve the 'current' menubar; either NULL or the last on in the mMenuBarList.

Definition at line 383 of file CommandManager.cpp.

{
   if(mMenuBarList.empty())
      return NULL;
 
   return mMenuBarList.back().menubar;
}

References mMenuBarList.

Referenced by EndMainMenu().

Here is the caller graph for this function:

◆ CurrentSubMenu()

wxMenu * CommandManager::CurrentSubMenu ( ) const

private

This returns the 'Current' Submenu, which is the one at the end of the mSubMenuList (or NULL, if it doesn't exist).

Definition at line 493 of file CommandManager.cpp.

{
   if(mSubMenuList.empty())
      return NULL;
 
   return mSubMenuList.back().menu.get();
}

References mSubMenuList.

Referenced by CurrentMenu().

Here is the caller graph for this function:

◆ DescribeCommandsAndShortcuts()

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

Formatting summaries that include shortcut keys

Definition at line 1043 of file CommandManager.cpp.

{
   wxString mark;
   // This depends on the language setting and may change in-session after
   // change of preferences:
   bool rtl = (wxLayout_RightToLeft == wxTheApp->GetLayoutDirection());
   if (rtl)
      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(), name, Verbatim(), and wxT().

Here is the call graph for this function:

◆ DoRepeatProcess()

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

Definition at line 1315 of file CommandManager.cpp.

                                                                          {
   mLastProcessId = 0;  //Don't Process this as repeat
   CommandListEntry* entry = mCommandNumericIDHash[id];
   // 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, cloud::audiocom::anonymous_namespace{AuthorizationHandler.cpp}::handler, id, 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 911 of file CommandManager.cpp.

{
   if (!entry->menu) {
      entry->enabled = enabled;
      return;
   }
 
   // LL:  Refresh from real state as we can get out of sync on the
   //      Mac due to its reluctance to enable menus when in a modal
   //      state.
   entry->enabled = entry->menu->IsEnabled(entry->id);
 
   // Only enabled if needed
   if (entry->enabled != enabled) {
      entry->menu->Enable(entry->id, enabled);
      entry->enabled = entry->menu->IsEnabled(entry->id);
   }
 
   if (entry->multi) {
      int i;
      int ID = entry->id;
 
      for(i=1; 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
         CommandListEntry *multiEntry = mCommandNumericIDHash[ID];
         if (multiEntry) {
            wxMenuItem *item = multiEntry->menu->FindItem(ID);
 
         if (item) {
            item->Enable(enabled);
         } else {
            // using GET in a log message for devs' eyes only
            wxLogDebug(wxT("Warning: Menu entry with id %i in %s not found"),
                ID, entry->name.GET());
         }
         } else {
            wxLogDebug(wxT("Warning: Menu entry with id %i not in hash"), ID);
         }
      }
   }
}

References entry, mCommandNumericIDHash, CommandListEntry::menu, 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 956 of file CommandManager.cpp.

{
   CommandListEntry *entry = mCommandNameHash[name];
   if (!entry || !entry->menu) {
      wxLogDebug(wxT("Warning: Unknown command enabled: '%s'"),
                 (const wxChar*)name);
      return;
   }
 
   Enable(entry, enabled);
}

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

Referenced by Enable(), and EnableUsingFlags().

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 968 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.get(), enable);
      }
   }
}

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

Here is the call graph for this function:

◆ EndMainMenu()

void CommandManager::EndMainMenu ( )

private

This attaches a menu to the menubar and ends the menu

Definition at line 446 of file CommandManager.cpp.

{
   // Add the menu to the menubar after all menu items have been
   // added to the menu to allow OSX to rearrange special menu
   // items like Preferences, About, and Quit.
   wxASSERT(uCurrentMenu);
   CurrentMenuBar()->Append(
      uCurrentMenu.release(), mCurrentMenuName.Translation());
   mCurrentMenu = nullptr;
   mCurrentMenuName = COMMAND;
}

References COMMAND, CurrentMenuBar(), mCurrentMenu, mCurrentMenuName, TranslatableString::Translation(), and uCurrentMenu.

Referenced by EndMenu().

Here is the call graph for this function:

Here is the caller graph for this function:

◆ EndMenu()

void CommandManager::EndMenu ( )

This attaches a menu, if it's main, to the menubar.

Definition at line 422 of file CommandManager.cpp.

{
   if ( mSubMenuList.empty() )
      EndMainMenu();
   else
      EndSubMenu();
}

References EndMainMenu(), EndSubMenu(), and mSubMenuList.

Here is the call graph for this function:

◆ EndOccultCommands()

void CommandManager::EndOccultCommands ( )

Definition at line 1625 of file CommandManager.cpp.

{
   PopMenuBar();
   bMakingOccultCommands = false;
   mTempMenuBar.reset();
}

References bMakingOccultCommands, mTempMenuBar, and PopMenuBar().

Here is the call graph for this function:

◆ EndSubMenu()

void CommandManager::EndSubMenu ( )

private

This function is called after the final item of a SUBmenu is added. Submenu items are added just like regular menu items; they just happen after BeginSubMenu() is called but before EndSubMenu() is called.

Definition at line 474 of file CommandManager.cpp.

{
   //Save the submenu's information
   SubMenuListEntry tmpSubMenu{ std::move( mSubMenuList.back() ) };
 
   //Pop off the NEW submenu so CurrentMenu returns the parent of the submenu
   mSubMenuList.pop_back();
 
   //Add the submenu to the current menu
   auto name = tmpSubMenu.name.Translation();
   CurrentMenu()->Append(0, name, tmpSubMenu.menu.release(),
      name /* help string */ );
   mbSeparatorAllowed = true;
}

References CurrentMenu(), mbSeparatorAllowed, mSubMenuList, name, and TranslatableString::Translation().

Referenced by EndMenu().

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 238 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 PackedArray::begin(), and PackedArray::end().

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

Here is the call graph for this function:

Here is the caller graph for this function:

◆ FilterKeyEvent()

bool CommandManager::FilterKeyEvent	(	AudacityProject *	project,
		const wxKeyEvent &	evt,
		bool	permit = `false`
	)

Definition at line 1099 of file CommandManager.cpp.

{
   if (!project)
      return false;
   
   auto pWindow = FindProjectFrame( project );
   CommandListEntry *entry = mCommandKeyHash[KeyEventToKeyString(evt)];
   if (entry == NULL)
   {
      return false;
   }
 
   int type = evt.GetEventType();
 
   // Global commands aren't tied to any specific project
   if (entry->isGlobal && type == wxEVT_KEY_DOWN)
   {
      // Global commands are always disabled so they do not interfere with the
      // rest of the command handling.  But, to use the common handler, we
      // enable them temporarily and then disable them again after handling.
      // LL:  Why do they need to be disabled???
      entry->enabled = false;
      auto cleanup = valueRestorer( entry->enabled, true );
      return HandleCommandEntry(*project, entry, NoFlagsSpecified, false, &evt);
   }
 
   wxWindow * pFocus = wxWindow::FindFocus();
   wxWindow * pParent = wxGetTopLevelParent( pFocus );
   bool validTarget = pParent == pWindow;
   // Bug 1557.  MixerBoard should count as 'destined for project'
   // MixerBoard IS a TopLevelWindow, and its parent is the project.
   if( pParent && pParent->GetParent() == pWindow ){
      if(auto keystrokeHandlingWindow = dynamic_cast< TopLevelKeystrokeHandlingWindow* >( pParent ))
         validTarget = keystrokeHandlingWindow->HandleCommandKeystrokes();
   }
   validTarget = validTarget && wxEventLoop::GetActive()->IsMain();
 
   // Any other keypresses must be destined for this project window
   if (!permit && !validTarget )
   {
      return false;
   }
 
   auto flags = MenuManager::Get(*project).GetUpdateFlags();
 
   wxKeyEvent temp = evt;
 
   // Possibly let wxWidgets do its normal key handling IF it is one of
   // the standard navigation keys.
   if((type == wxEVT_KEY_DOWN) || (type == wxEVT_KEY_UP ))
   {
      wxWindow * pWnd = wxWindow::FindFocus();
      bool bIntercept =
         pWnd && !dynamic_cast< NonKeystrokeInterceptingWindow * >( pWnd );
 
      //wxLogDebug("Focus: %p TrackPanel: %p", pWnd, pTrackPanel );
      // We allow the keystrokes below to be handled by wxWidgets controls IF we are
      // in some sub window rather than in the TrackPanel itself.
      // Otherwise they will go to our command handler and if it handles them
      // they will NOT be available to wxWidgets.
      if( bIntercept ){
         switch( evt.GetKeyCode() ){
         case WXK_LEFT:
         case WXK_RIGHT:
         case WXK_UP:
         case WXK_DOWN:
         // Don't trap WXK_SPACE (Bug 1727 - SPACE not starting/stopping playback
         // when cursor is in a time control)
         // case WXK_SPACE:
         case WXK_TAB:
         case WXK_BACK:
         case WXK_HOME:
         case WXK_END:
         case WXK_RETURN:
         case WXK_NUMPAD_ENTER:
         case WXK_DELETE:
         case '0':
         case '1':
         case '2':
         case '3':
         case '4':
         case '5':
         case '6':
         case '7':
         case '8':
         case '9':
            return false;
         case ',':
         case '.':
            if (!evt.HasAnyModifiers())
               return false;
         }
      }
   }
 
   if (type == wxEVT_KEY_DOWN)
   {
      if (entry->skipKeydown)
      {
         return true;
      }
      return HandleCommandEntry(*project, entry, flags, false, &temp);
   }
 
   if (type == wxEVT_KEY_UP && entry->wantKeyup)
   {
      return HandleCommandEntry(*project, entry, flags, false, &temp);
   }
 
   return false;
}

References entry, BasicUI::FindFocus(), FindProjectFrame(), MenuManager::Get(), MenuManager::GetUpdateFlags(), HandleCommandEntry(), KeyEventToKeyString(), mCommandKeyHash, NoFlagsSpecified, project, and valueRestorer().

Here is the call graph for this function:

◆ FormatLabelForMenu() [1/3]

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 808 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 FormatLabelForMenu(*pLabel, keyStr);
   return {};
}

References FormatLabelForMenu(), and mCommandNameHash.

Referenced by AddItemList(), FormatLabelForMenu(), and Modify().

Here is the call graph for this function:

Here is the caller graph for this function:

◆ FormatLabelForMenu() [2/3]

wxString CommandManager::FormatLabelForMenu ( const CommandListEntry * entry ) const

private

Definition at line 824 of file CommandManager.cpp.

{
   return FormatLabelForMenu( entry->label, entry->key );
}

References entry, and FormatLabelForMenu().

Here is the call graph for this function:

◆ FormatLabelForMenu() [3/3]

wxString CommandManager::FormatLabelForMenu	(	const TranslatableString &	translatableLabel,
		const NormalizedKeyString &	keyStr
	)		const

private

Definition at line 829 of file CommandManager.cpp.

{
   auto label = translatableLabel.Translation();
   auto key = keyStr.GET();
   if (!key.empty())
   {
      // using GET to compose menu item name for wxWidgets
      label += wxT("\t") + key;
   }
 
   return label;
}

References Identifier::GET(), key, label, TranslatableString::Translation(), and wxT().

Here is the call graph for this function:

◆ FormatLabelWithDisabledAccel()

wxString CommandManager::FormatLabelWithDisabledAccel ( const CommandListEntry * entry ) const

private

Definition at line 849 of file CommandManager.cpp.

{
   auto label = entry->label.Translation();
#if 1
   wxString Accel;
   do{
      if (!entry->key.empty())
      {
         // Dummy accelerator that looks Ok in menus but is non functional.
         // Note the space before the key.
#ifdef __WXMSW__
         // using GET to compose menu item name for wxWidgets
         auto key = entry->key.GET();
         Accel = wxString("\t ") + key;
         if( key.StartsWith("Left" )) break;
         if( key.StartsWith("Right")) break;
         if( key.StartsWith("Up" )) break;
         if( key.StartsWith("Down")) break;
         if( key.StartsWith("Return")) break;
         if( key.StartsWith("Tab")) break;
         if( key.StartsWith("Shift+Tab")) break;
         if( key.StartsWith("0")) break;
         if( key.StartsWith("1")) break;
         if( key.StartsWith("2")) break;
         if( key.StartsWith("3")) break;
         if( key.StartsWith("4")) break;
         if( key.StartsWith("5")) break;
         if( key.StartsWith("6")) break;
         if( key.StartsWith("7")) break;
         if( key.StartsWith("8")) break;
         if( key.StartsWith("9")) break;
         // Uncomment the below so as not to add the illegal accelerators.
         // Accel = "";
         //if( entry->key.StartsWith("Space" )) break;
         // These ones appear to be illegal already and mess up accelerator processing.
         if( key.StartsWith("NUMPAD_ENTER" )) break;
         if( key.StartsWith("Backspace" )) break;
         if( key.StartsWith("Delete" )) break;
 
         // https://github.com/audacity/audacity/issues/4457
         // This code was proposed by David Bailes to fix
         // the decimal separator input in wxTextCtrls that
         // are children of the main window. 
         if( key.StartsWith(",") ) break;
         if( key.StartsWith(".") ) break;
 
#endif
         //wxLogDebug("Added Accel:[%s][%s]", entry->label, entry->key );
         // Normal accelerator.
         // using GET to compose menu item name for wxWidgets
         Accel = wxString("\t") + entry->key.GET();
      }
   } while (false );
   label += Accel;
#endif
   return label;
}

References entry, key, and label.

Referenced by AddItem().

Here is the caller graph for this function:

◆ Get() [1/2]

CommandManager & CommandManager::Get ( AudacityProject & project )

static

Definition at line 206 of file CommandManager.cpp.

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

References key, and project.

Here is the caller graph for this function:

◆ Get() [2/2]

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

static

Definition at line 211 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,
		bool	includeMultis
	)

Definition at line 1451 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);
#if defined(EXPERIMENTAL_KEY_VIEW)
         prefixes.push_back(entry->labelPrefix);
#endif
      }
   }
}

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 1432 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 1419 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 ( AudacityProject & )

Definition at line 1387 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 )

Definition at line 1512 of file CommandManager.cpp.

{
   CommandListEntry *entry = mCommandNameHash[name];
   if (!entry)
      return {};
 
   return entry->labelTop;
}

References entry, mCommandNameHash, and name.

Referenced by KeyConfigPrefs::OnSet().

Here is the caller graph for this function:

◆ GetDefaultKeyFromName()

NormalizedKeyString CommandManager::GetDefaultKeyFromName ( const CommandID & name )

Definition at line 1532 of file CommandManager.cpp.

{
   CommandListEntry *entry = mCommandNameHash[name];
   if (!entry)
      return {};
 
   return entry->defaultKey;
}

References entry, mCommandNameHash, and name.

Referenced by KeyConfigPrefs::OnSet().

Here is the caller graph for this function:

◆ GetEnabled()

bool CommandManager::GetEnabled ( const CommandID & name )

Definition at line 992 of file CommandManager.cpp.

{
   CommandListEntry *entry = mCommandNameHash[name];
   if (!entry || !entry->menu) {
      // using GET in a log message for devs' eyes only
      wxLogDebug(wxT("Warning: command doesn't exist: '%s'"),
                 name.GET());
      return false;
   }
   return entry->enabled;
}

References entry, 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 1521 of file CommandManager.cpp.

{
   CommandListEntry *entry =
      // May create a NULL entry
      const_cast<CommandManager*>(this)->mCommandNameHash[name];
   if (!entry)
      return {};
 
   return entry->key;
}

References entry, 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 )

Definition at line 1489 of file CommandManager.cpp.

{
   CommandListEntry *entry = mCommandNameHash[name];
   if (!entry)
      return {};
 
   return entry->longLabel;
}

References entry, mCommandNameHash, and name.

◆ GetMenuBar()

wxMenuBar * CommandManager::GetMenuBar ( const wxString & sMenu ) const

private

Retrieves the menubar based on the name given in AddMenuBar(name)

Definition at line 368 of file CommandManager.cpp.

{
   for (const auto &entry : mMenuBarList)
   {
      if(entry.name == sMenu)
         return entry.menubar;
   }
 
   return NULL;
}

References entry, and mMenuBarList.

Referenced by AddMenuBar().

Here is the caller graph for this function:

◆ GetNameFromNumericID()

CommandID CommandManager::GetNameFromNumericID ( int id )

Definition at line 1481 of file CommandManager.cpp.

{
   CommandListEntry *entry = mCommandNumericIDHash[id];
   if (!entry)
      return {};
   return entry->name;
}

References entry, id, and mCommandNumericIDHash.

◆ GetNumberOfKeysRead()

int CommandManager::GetNumberOfKeysRead ( ) const

Definition at line 1004 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 )

Definition at line 1498 of file CommandManager.cpp.

{
   CommandListEntry *entry = mCommandNameHash[name];
   if (!entry)
      return {};
 
   if (!entry->labelPrefix.empty())
      return Verbatim( wxT("%s - %s") )
         .Format(entry->labelPrefix, entry->label)
            .Stripped();
   else
      return entry->label.Stripped();
}

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:

◆ HandleCommandEntry()

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

private

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 1242 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 =
         MenuManager::Get(project).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 = {};
   }
 
   Journal::Output({ JournalCode, entry->name.GET() });
 
   CommandContext context{ project, evt, entry->index, entry->parameter };
   if (pGivenContext)
      context.temporarySelection = pGivenContext->temporarySelection;
   // Discriminate the union entry->callback by entry->finder
   if (auto &finder = entry->finder) {
      auto &handler = finder(project);
      (handler.*(entry->callback.memberFn))(context);
   }
   else
      (entry->callback.nonMemberFn)(context);
   mLastProcessId = 0;
   return true;
}

References AlwaysEnabledFlag, TranslatableString::Ellipses, entry, MenuManager::Get(), cloud::audiocom::anonymous_namespace{AuthorizationHandler.cpp}::handler, anonymous_namespace{CommandManager.cpp}::JournalCode, TranslatableString::MenuCodes, mLastProcessId, mNiceName, Journal::Output(), project, MenuManager::ReportIfActionNotAllowed(), and CommandContext::temporarySelection.

Referenced by FilterKeyEvent(), HandleMenuID(), and HandleTextualCommand().

Here is the call graph for this function:

Here is the caller graph for this function:

◆ HandleMenuID()

bool CommandManager::HandleMenuID	(	AudacityProject &	project,
		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 1333 of file CommandManager.cpp.

{
   mLastProcessId = id;
   CommandListEntry *entry = mCommandNumericIDHash[id];
 
   if (GlobalMenuHook::Call(entry->name))
      return true;
 
   return HandleCommandEntry( project, entry, flags, alwaysEnabled );
}

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

Here is the call graph for this function:

◆ HandleTextualCommand()

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

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 1349 of file CommandManager.cpp.

{
   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(
               context.project, entry.get(), flags, alwaysEnabled,
               nullptr, &context)
               ? CommandSuccess : CommandFailure;
         }
      }
      else
      {
         // Handle multis too...
         if( Str == entry->name )
         {
            return HandleCommandEntry(
               context.project, entry.get(), flags, alwaysEnabled,
               nullptr, &context)
               ? CommandSuccess : CommandFailure;
         }
      }
   }
   return CommandNotFound;
}

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

Referenced by CommandDispatch::HandleTextualCommand().

Here is the call graph for this function:

Here is the caller graph for this function:

◆ HandleXMLChild()

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

overrideprivatevirtual

Implements XMLTagHandler.

Definition at line 1590 of file CommandManager.cpp.

{
   return this;
}

◆ HandleXMLEndTag()

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

overrideprivate

Definition at line 1577 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 1541 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 (mCommandNameHash[name]) {
         mCommandNameHash[name]->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 1019 of file CommandManager.cpp.

{
   CommandListEntry *entry = mCommandNameHash[name];
   if (entry && entry->menu) {
      entry->label = newLabel;
      entry->menu->SetLabel(entry->id, FormatLabelForMenu(entry));
   }
}

References entry, FormatLabelForMenu(), mCommandNameHash, and name.

Referenced by RegisterLastAnalyzer(), and RegisterLastTool().

Here is the call graph for this function:

Here is the caller graph for this function:

◆ NewIdentifier()

CommandListEntry * CommandManager::NewIdentifier	(	const CommandID &	nameIn,
		const TranslatableString &	label,
		wxMenu *	menu,
		CommandHandlerFinder	finder,
		CommandFunctorPointer	callback,
		const CommandID &	nameSuffix,
		int	index,
		int	count,
		const Options &	options
	)

private

Given all of the information for a command, comes up with a NEW unique ID, adds it to a list, and returns the ID. WARNING: Does this conflict with the identifiers set for controls/windows? If it does, a workaround may be to keep controls below wxID_LOWEST and keep menus above wxID_HIGHEST

Definition at line 655 of file CommandManager.cpp.

{
   bool excludeFromMacros =
      (options.allowInMacros == 0) ||
      ((options.allowInMacros == -1) && label.MSGID().GET().Contains("..."));
 
   const wxString & accel = options.accel;
   bool bIsEffect = options.bIsEffect;
   CommandID parameter = options.parameter == "" ? nameIn : options.parameter;
 
   // if empty, new identifier's long label will be same as label, below:
   const auto &longLabel = options.longName;
 
   const bool multi = !nameSuffix.empty();
   auto name = nameIn;
 
   // If we have the identifier already, reuse it.
   CommandListEntry *prev = mCommandNameHash[name];
   if (!prev);
   else if( prev->label != label );
   else if( multi );
   else
      return prev;
 
   {
      auto entry = std::make_unique<CommandListEntry>();
 
      TranslatableString labelPrefix;
      if (!mSubMenuList.empty())
         labelPrefix = mSubMenuList.back().name.Stripped();
 
      // For key bindings for commands with a list, such as align,
      // the name in prefs is the category name plus the effect name.
      // This feature is not used for built-in effects.
      if (multi)
         name = CommandID{ { name, nameSuffix }, wxT('_') };
 
      // wxMac 2.5 and higher will do special things with the
      // Preferences, Exit (Quit), and About menu items,
      // if we give them the right IDs.
      // Otherwise we just pick increasing ID numbers for each NEW
      // command.  Note that the name string we are comparing
      // ("About", "Preferences") is the internal command name
      // (untranslated), not the label that actually appears in the
      // menu (which might be translated).
 
      mCurrentID = NextIdentifier(mCurrentID);
      entry->id = mCurrentID;
      entry->parameter = parameter;
 
#if defined(__WXMAC__)
      // See bug #2642 for some history as to why these items 
      // on Mac have their IDs set explicitly and not others.
      if (name == wxT("Preferences"))
         entry->id = wxID_PREFERENCES;
      else if (name == wxT("Exit"))
         entry->id = wxID_EXIT;
      else if (name == wxT("About"))
         entry->id = wxID_ABOUT;
#endif
 
      entry->name = name;
      entry->label = label;
 
      // long label is the same as label unless options specified otherwise:
      entry->longLabel = longLabel.empty() ? label : longLabel;
 
      entry->excludeFromMacros = excludeFromMacros;
      entry->key = NormalizedKeyString{ accel.BeforeFirst(wxT('\t')) };
      entry->defaultKey = entry->key;
      entry->labelPrefix = labelPrefix;
      entry->labelTop = mCurrentMenuName.Stripped();
      entry->menu = menu;
      entry->finder = finder;
      entry->callback = callback;
      entry->isEffect = bIsEffect;
      entry->multi = multi;
      entry->index = index;
      entry->count = count;
      entry->flags = AlwaysEnabledFlag;
      entry->enabled = true;
      entry->skipKeydown = options.skipKeyDown;
      entry->wantKeyup = options.wantKeyUp || entry->skipKeydown;
      entry->allowDup = options.allowDup;
      entry->isGlobal = false;
      entry->isOccult = bMakingOccultCommands;
      entry->checkmarkFn = options.checker;
 
      // Exclude accelerators that are in the MaxList.
      // Note that the default is unaffected, intentionally so.
      // There are effectively two levels of default, the full (max) list
      // and the normal reduced list.
      if( std::binary_search( mMaxListOnly.begin(), mMaxListOnly.end(),
                              entry->key ) )
      {
         entry->key = {};
      }
      auto newKeysGroup = gPrefs->BeginGroup("/NewKeys");
      // using GET to interpret CommandID as a config path component
      const auto &path = entry->name.GET();
      if (gPrefs->HasEntry(path)) {
         // Key from preferences overrides the default key given
         entry->key =
            NormalizedKeyString{ gPrefs->Read(path, entry->key) };
      }
 
      mCommandList.push_back(std::move(entry));
      // Don't use the variable entry eny more!
   }
 
   // New variable
   CommandListEntry *entry = &*mCommandList.back();
   mCommandNumericIDHash[entry->id] = entry;
 
#if defined(_DEBUG)
   prev = mCommandNameHash[entry->name];
   if (prev) {
      // Under Linux it looks as if we may ask for a newID for the same command
      // more than once.  So it's only an error if two different commands
      // have the exact same name.
      if( prev->label != entry->label )
      {
         wxLogDebug(wxT("Command '%s' defined by '%s' and '%s'"),
                    // using GET in a log message for devs' eyes only
                    entry->name.GET(),
                    prev->label.Debug(),
                    entry->label.Debug());
         wxFAIL_MSG(wxString::Format(wxT("Command '%s' defined by '%s' and '%s'"),
                    // using GET in an assertion violation message for devs'
                    // eyes only
                    entry->name.GET(),
                    prev->label.Debug(),
                    entry->label.Debug()));
      }
   }
#endif
   mCommandNameHash[entry->name] = entry;
 
   if (!entry->key.empty()) {
      mCommandKeyHash[entry->key] = entry;
   }
 
   return entry;
}

Referenced by AddGlobalCommand(), AddItem(), and AddItemList().

Here is the call graph for this function:

Here is the caller graph for this function:

◆ NextIdentifier()

int CommandManager::NextIdentifier ( int ID )

private

Definition at line 639 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 NewIdentifier().

Here is the caller graph for this function:

◆ operator=()

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

delete

◆ PopMenuBar()

void CommandManager::PopMenuBar ( )

Typically used to switch back and forth between adding to a hidden menu bar and adding to one that is visible

Definition at line 396 of file CommandManager.cpp.

{
   auto iter = mMenuBarList.end();
   if ( iter != mMenuBarList.begin() )
      mMenuBarList.erase( --iter );
   else
      wxASSERT( false );
}

References mMenuBarList.

Referenced by EndOccultCommands().

Here is the caller graph for this function:

◆ PurgeData()

void CommandManager::PurgeData ( )

Definition at line 327 of file CommandManager.cpp.

{
   // mCommandList contains pointers to CommandListEntrys
   // mMenuBarList contains MenuBarListEntrys.
   // mSubMenuList contains SubMenuListEntrys
   mCommandList.clear();
   mMenuBarList.clear();
   mSubMenuList.clear();
 
   mCommandNameHash.clear();
   mCommandKeyHash.clear();
   mCommandNumericIDHash.clear();
 
   mCurrentMenuName = COMMAND;
   mCurrentID = 17000;
}

References COMMAND, mCommandKeyHash, mCommandList, mCommandNameHash, mCommandNumericIDHash, mCurrentID, mCurrentMenuName, mMenuBarList, and mSubMenuList.

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

Here is the caller graph for this function:

◆ RegisterLastAnalyzer()

void CommandManager::RegisterLastAnalyzer ( const CommandContext & context )

Definition at line 1290 of file CommandManager.cpp.

                                                                       {
   if (mLastProcessId != 0) {
      auto& menuManager = MenuManager::Get(context.project);
      menuManager.mLastAnalyzerRegistration = MenuCreator::repeattypeunique;
      menuManager.mLastAnalyzerRegisteredId = mLastProcessId;
      auto lastEffectDesc = XO("Repeat %s").Format(mNiceName);
      Modify(wxT("RepeatLastAnalyzer"), lastEffectDesc);
   }
   return;
}

References MenuManager::Get(), mLastProcessId, mNiceName, Modify(), CommandContext::project, MenuCreator::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 1303 of file CommandManager.cpp.

                                                                   {
   if (mLastProcessId != 0) {
      auto& menuManager = MenuManager::Get(context.project);
      menuManager.mLastToolRegistration = MenuCreator::repeattypeunique;
      menuManager.mLastToolRegisteredId = mLastProcessId;
      auto lastEffectDesc = XO("Repeat %s").Format(mNiceName);
      Modify(wxT("RepeatLastTool"), lastEffectDesc);
   }
   return;
}

References MenuManager::Get(), mLastProcessId, mNiceName, Modify(), CommandContext::project, MenuCreator::repeattypeunique, wxT(), and XO().

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

Here is the call graph for this function:

Here is the caller graph for this function:

◆ RemoveDuplicateShortcuts()

void CommandManager::RemoveDuplicateShortcuts ( )

Definition at line 1686 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());
               }
            }
         }
      }
   }
 
   if (!disabledShortcuts.Translation().empty()) {
      TranslatableString message = XO("The following commands have had their shortcuts removed,"
      " because their default shortcut is new or changed, and is the same shortcut"
      " that you have assigned to another command.")
         + disabledShortcuts;
      AudacityMessageBox(message, XO("Shortcuts have been removed"), wxOK | wxCENTRE);
 
      gPrefs->Flush();
      MenuCreator::RebuildAllMenuBars();
   }
}

References AudacityMessageBox(), entry, audacity::BasicSettings::Flush(), gPrefs, mCommandList, name, MenuCreator::RebuildAllMenuBars(), TranslatableString::Translation(), audacity::BasicSettings::Write(), wxT(), and XO().

Referenced by AudacityApp::InitPart2().

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 1632 of file CommandManager.cpp.

{
   CommandListEntry *entry = mCommandNameHash[name];
   if (entry)
      entry->flags = flags;
}

References entry, mCommandNameHash, and name.

Referenced by AddItem().

Here is the caller graph for this function:

◆ SetKeyFromIndex()

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

Definition at line 1037 of file CommandManager.cpp.

{
   const auto &entry = mCommandList[i];
   entry->key = key;
}

References entry, key, and mCommandList.

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

Here is the caller graph for this function:

◆ SetKeyFromName()

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

Definition at line 1028 of file CommandManager.cpp.

{
   CommandListEntry *entry = mCommandNameHash[name];
   if (entry) {
      entry->key = key;
   }
}

References entry, key, mCommandNameHash, and name.

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

Here is the caller graph for this function:

◆ SetMaxList()

void CommandManager::SetMaxList ( )

Definition at line 306 of file CommandManager.cpp.

{
 
   // This list is a DUPLICATE of the list in
   // KeyConfigPrefs::OnImportDefaults(wxCommandEvent & event)
 
   // TODO: At a later date get rid of the maxList entirely and
   // instead use flags in the menu entries to indicate whether the default
   // shortcut is standard or full.
 
   mMaxListOnly.clear();
 
   // if the full list, don't exclude any.
   bool bFull = gPrefs->ReadBool(wxT("/GUI/Shortcuts/FullDefaults"),false);
   if( bFull )
      return;
 
   mMaxListOnly = ExcludedList();
}

References ExcludedList(), gPrefs, mMaxListOnly, audacity::BasicSettings::ReadBool(), and wxT().

Referenced by CommandManager().

Here is the call graph for this function:

Here is the caller graph for this function:

◆ UpdateCheckmarks()

void CommandManager::UpdateCheckmarks ( AudacityProject & project )

Definition at line 520 of file CommandManager.cpp.

{
   for ( const auto &entry : mCommandList ) {
      if ( entry->menu && entry->checkmarkFn && !entry->isOccult) {
         entry->menu->Check( entry->id, entry->checkmarkFn( project ) );
      }
   }
}

References entry, mCommandList, and project.

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

Here is the caller graph for this function:

◆ WriteXML()

void CommandManager::WriteXML ( XMLWriter & xmlFile ) const

Definition at line 1595 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, 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

◆ bMakingOccultCommands

bool CommandManager::bMakingOccultCommands

private

Definition at line 387 of file CommandManager.h.

Referenced by BeginOccultCommands(), EndOccultCommands(), and NewIdentifier().

◆ mbSeparatorAllowed

bool CommandManager::mbSeparatorAllowed

private

Definition at line 379 of file CommandManager.h.

Referenced by AddItem(), AddItemList(), AddSeparator(), BeginSubMenu(), CommandManager(), and EndSubMenu().

◆ mCommandKeyHash

CommandKeyHash CommandManager::mCommandKeyHash

private

Definition at line 374 of file CommandManager.h.

Referenced by FilterKeyEvent(), NewIdentifier(), and PurgeData().

◆ mCommandList

CommandList CommandManager::mCommandList

private

Definition at line 372 of file CommandManager.h.

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

◆ mCommandNameHash

CommandNameHash CommandManager::mCommandNameHash

private

Definition at line 373 of file CommandManager.h.

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

◆ mCommandNumericIDHash

CommandNumericIDHash CommandManager::mCommandNumericIDHash

private

Definition at line 375 of file CommandManager.h.

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

◆ mCurrentID

int CommandManager::mCurrentID

private

Definition at line 376 of file CommandManager.h.

Referenced by NewIdentifier(), and PurgeData().

◆ mCurrentMenu

wxMenu* CommandManager::mCurrentMenu {}

private

Definition at line 385 of file CommandManager.h.

Referenced by BeginMainMenu(), BeginMenu(), CurrentMenu(), and EndMainMenu().

◆ mCurrentMenuName

TranslatableString CommandManager::mCurrentMenuName

private

Definition at line 381 of file CommandManager.h.

Referenced by BeginMainMenu(), EndMainMenu(), NewIdentifier(), and PurgeData().

◆ mLastProcessId

int CommandManager::mLastProcessId

private

Definition at line 383 of file CommandManager.h.

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

◆ mMaxListOnly

std::vector<NormalizedKeyString> CommandManager::mMaxListOnly

private

Definition at line 368 of file CommandManager.h.

Referenced by NewIdentifier(), and SetMaxList().

◆ mMenuBarList

MenuBarList CommandManager::mMenuBarList

private

Definition at line 370 of file CommandManager.h.

Referenced by AddMenuBar(), CurrentMenuBar(), GetMenuBar(), PopMenuBar(), and PurgeData().

◆ mNiceName

TranslatableString CommandManager::mNiceName

private

Definition at line 382 of file CommandManager.h.

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

◆ mSubMenuList

SubMenuList CommandManager::mSubMenuList

private

Definition at line 371 of file CommandManager.h.

Referenced by BeginSubMenu(), CurrentSubMenu(), EndMenu(), EndSubMenu(), NewIdentifier(), and PurgeData().

◆ mTempMenuBar

std::unique_ptr< wxMenuBar > CommandManager::mTempMenuBar

private

Definition at line 388 of file CommandManager.h.

Referenced by BeginOccultCommands(), and EndOccultCommands().

◆ mXMLKeysRead

int CommandManager::mXMLKeysRead

private

Definition at line 377 of file CommandManager.h.

Referenced by GetNumberOfKeysRead(), and HandleXMLTag().

◆ uCurrentMenu

std::unique_ptr<wxMenu> CommandManager::uCurrentMenu

private

Definition at line 384 of file CommandManager.h.

Referenced by BeginMainMenu(), and EndMainMenu().

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

Classes

Public Types

Public Member Functions

Static Public Member Functions

Private Member Functions

Private Attributes

Detailed Description

Member Typedef Documentation

◆ CheckFn

Member Enumeration Documentation

◆ TextualCommandResult

Constructor & Destructor Documentation

◆ CommandManager() [1/2]

◆ ~CommandManager()

◆ CommandManager() [2/2]

Member Function Documentation

◆ AddGlobalCommand()

◆ AddItem()

◆ AddItemList()

◆ AddMenuBar()

◆ AddSeparator()

◆ BeginMainMenu()

◆ BeginMenu()

◆ BeginOccultCommands()

◆ BeginSubMenu()

◆ Check()

◆ CurrentMenu()

◆ CurrentMenuBar()

◆ CurrentSubMenu()

◆ DescribeCommandsAndShortcuts()

◆ DoRepeatProcess()

◆ Enable() [1/2]

◆ Enable() [2/2]

◆ EnableUsingFlags()

◆ EndMainMenu()

◆ EndMenu()

◆ EndOccultCommands()

◆ EndSubMenu()

◆ ExcludedList()

◆ FilterKeyEvent()

◆ FormatLabelForMenu() [1/3]

◆ FormatLabelForMenu() [2/3]

◆ FormatLabelForMenu() [3/3]

◆ FormatLabelWithDisabledAccel()

◆ Get() [1/2]

◆ Get() [2/2]

◆ GetAllCommandData()

◆ GetAllCommandLabels()

◆ GetAllCommandNames()

◆ GetCategories()

◆ GetCategoryFromName()

◆ GetDefaultKeyFromName()

◆ GetEnabled()

◆ GetKeyFromName()

◆ GetLabelFromName()

◆ GetMenuBar()

◆ GetNameFromNumericID()

◆ GetNumberOfKeysRead()

◆ GetPrefixedLabelFromName()

◆ HandleCommandEntry()

◆ HandleMenuID()

◆ HandleTextualCommand()

◆ HandleXMLChild()

◆ HandleXMLEndTag()

◆ HandleXMLTag()

◆ Modify()

◆ NewIdentifier()

◆ NextIdentifier()

◆ operator=()

◆ PopMenuBar()

◆ PurgeData()

◆ RegisterLastAnalyzer()

◆ RegisterLastTool()

◆ RemoveDuplicateShortcuts()

◆ SetCommandFlags()

◆ SetKeyFromIndex()

◆ SetKeyFromName()

◆ SetMaxList()

◆ UpdateCheckmarks()

◆ WriteXML()