CommandManager::Populator Struct Reference

#include <CommandManager.h>

Inheritance diagram for CommandManager::Populator:

Collaboration diagram for CommandManager::Populator:

Public Types
using	LeafVisitor = std::function< void(const Registry::SingleItem &, const Registry::Path &)>
Public Types inherited from Registry::VisitorFunctions< MenuRegistry::Traits >
using	NodeTypes = detail::VisitedNodeTypes< MenuRegistry::Traits >
using	LeafTypes = detail::VisitedLeafTypes< MenuRegistry::Traits >

Public Member Functions
	Populator (AudacityProject &project, LeafVisitor leafVisitor, std::function< void()> doSeparator)
virtual	~Populator ()
Public Member Functions inherited from MenuRegistry::Visitor< MenuRegistry::Traits >
	Visitor (VisitorFunctions< MenuRegistry::Traits > functions, std::function< void()> doSeparator)
Public Member Functions inherited from Registry::VisitorFunctions< MenuRegistry::Traits >
	VisitorFunctions (Visitors &&visitors)
	Type-erasing constructor. More...
void	BeginGroup (const GroupItem< MenuRegistry::Traits > &item, const Path &path) const
	Call-through for a decorating pre-visitor. More...
void	Visit (const SingleItem &item, const Path &path) const
	Call-through for a decorating leaf-visitor. More...
void	EndGroup (const GroupItem< MenuRegistry::Traits > &item, const Path &path) const
	Call-through for a decorating post-visitor. More...
Public Member Functions inherited from MenuRegistry::detail::VisitorBase
std::pair< bool, bool >	ShouldBeginGroup (const ItemProperties *pProperties)
void	AfterBeginGroup (const ItemProperties *pProperties)
bool	ShouldEndGroup (const ItemProperties *pProperties)
bool	ShouldDoSeparator ()

Protected Member Functions
void	DoBeginGroup (const MenuRegistry::GroupItem< MenuRegistry::Traits > &item)
void	DoVisit (const Registry::SingleItem &item)
void	DoEndGroup (const MenuRegistry::GroupItem< MenuRegistry::Traits > &item)
virtual void	BeginMenu (const TranslatableString &tName)
virtual void	BeginOccultCommands ()
virtual void	EndMenu ()
virtual void	EndOccultCommands ()
virtual std::unique_ptr< CommandListEntry >	AllocateEntry (const MenuRegistry::Options &options)
virtual void	VisitEntry (CommandListEntry &entry, const MenuRegistry::Options *options)
void	DoSeparator ()
const TranslatableStrings &	MenuNames () const
	Stack of names of menus that were begun and not yet ended. More...

Protected Attributes
AudacityProject &	mProject
bool	mbSeparatorAllowed { false }

Private Member Functions
void	AddItemList (const CommandID &name, const ComponentInterfaceSymbol items[], size_t nItems, CommandHandlerFinder finder, CommandFunctorPointer callback, CommandFlag flags, bool bIsEffect=false)
void	AddItem (const CommandID &name, const TranslatableString &label_in, CommandHandlerFinder finder, CommandFunctorPointer callback, CommandFlag flags, const MenuRegistry::Options &options={})
CommandListEntry *	NewIdentifier (const CommandID &name, const TranslatableString &label, CommandHandlerFinder finder, CommandFunctorPointer callback, const CommandID &nameSuffix, int index, int count, const MenuRegistry::Options &options)
void	AddGlobalCommand (const CommandID &name, const TranslatableString &label, CommandHandlerFinder finder, CommandFunctorPointer callback, const MenuRegistry::Options &options={})
void	SetMaxList ()

Private Attributes
std::vector< NormalizedKeyString >	mMaxListOnly
TranslatableStrings	mMenuNames
std::vector< bool >	mFlags
int	mCurrentID { 17000 }
bool	bMakingOccultCommands { false }

Additional Inherited Members
Public Attributes inherited from MenuRegistry::detail::VisitorBase
std::vector< bool >	firstItem
std::vector< bool >	needSeparator

Detailed Description

Definition at line 122 of file CommandManager.h.

Member Typedef Documentation

LeafVisitor

using CommandManager::Populator::LeafVisitor = std::function< void(const Registry::SingleItem &, const Registry::Path&)>

Definition at line 125 of file CommandManager.h.

Constructor & Destructor Documentation

Populator()

CommandManager::Populator::Populator	(	AudacityProject &	project,
		LeafVisitor	leafVisitor,
		std::function< void()>	doSeparator
	)

Definition at line 85 of file CommandManager.cpp.

   : Visitor{
      std::tuple {
         [this](auto &item, auto &){ DoBeginGroup(item); },
         move(leafVisitor),
         [this](auto &item, auto &){ DoEndGroup(item); },
      },
      move(doSeparator)
   }
   , mProject{ project }
{
   // The list of defaults to exclude depends on
   // preference wxT("/GUI/Shortcuts/FullDefaults"), which may have changed.
   SetMaxList();
}

References DoBeginGroup().

Here is the call graph for this function:

~Populator()

CommandManager::Populator::~Populator ( )

virtualdefault

Member Function Documentation

AddGlobalCommand()

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

private

Definition at line 408 of file CommandManager.cpp.

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

References AlwaysEnabledFlag, entry, anonymous_namespace{Scrubbing.cpp}::finder, and name.

AddItem()

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

private

Definition at line 349 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,
         finder, callback,
         {}, 0, 0,
         options);
   entry->useStrictFlags = options.useStrictFlags;
   Get(mProject).SetCommandFlags(name, flags);
   mbSeparatorAllowed = true;
   VisitEntry(*entry, &options);
}

References entry, anonymous_namespace{Scrubbing.cpp}::finder, CommandManager::Get(), MenuRegistry::Options::global, CommandManager::mProject, name, NoFlagsSpecified, CommandManager::SetCommandFlags(), and MenuRegistry::Options::useStrictFlags.

Here is the call graph for this function:

AddItemList()

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

private

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

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

References entry, anonymous_namespace{Scrubbing.cpp}::finder, Internal, MenuRegistry::Options::IsEffect(), and name.

Here is the call graph for this function:

AllocateEntry()

auto CommandManager::Populator::AllocateEntry ( const MenuRegistry::Options &  options )

protectedvirtual

Called by DoVisit Override to make entries that carry extra information. Not called for every visit, because existing items may be reused

Postcondition

result: result != nullptr

Reimplemented in anonymous_namespace{MenuCreator.cpp}::MenuItemVisitor.

Definition at line 328 of file CommandManager.cpp.

{
   return std::make_unique<CommandListEntry>();
}

BeginMenu()

void CommandManager::Populator::BeginMenu ( const TranslatableString &  tName )

protectedvirtual

Called by DoBeginGroup Default implementation does nothing

Reimplemented in anonymous_namespace{MenuCreator.cpp}::MenuItemVisitor.

Definition at line 296 of file CommandManager.cpp.

{
}

BeginOccultCommands()

void CommandManager::Populator::BeginOccultCommands ( )

protectedvirtual

Called by DoBeginGroup Default implementation does nothing

Reimplemented in anonymous_namespace{MenuCreator.cpp}::MenuItemVisitor.

Definition at line 1195 of file CommandManager.cpp.

{
}

DoBeginGroup()

void CommandManager::Populator::DoBeginGroup ( const MenuRegistry::GroupItem< MenuRegistry::Traits > &  item )

protected

Definition at line 249 of file CommandManager.cpp.

{
   using namespace MenuRegistry;
   auto pItem = &item;
   if (const auto pMenu = dynamic_cast<const MenuItem*>( pItem )) {
      const auto &title = pMenu->GetTitle();
      mMenuNames.emplace_back(title);
      BeginMenu(title);
   }
   else if (const auto pConditionalGroup =
      dynamic_cast<const ConditionalGroupItem*>( pItem )
   ) {
      const auto flag = (*pConditionalGroup)();
      if (!flag) {
         bMakingOccultCommands = true;
         BeginOccultCommands();
      }
      // to avoid repeated call of condition predicate in EndGroup():
      mFlags.push_back(flag);
   }
   else
      assert(IsSection(item));
}

References flag, MenuRegistry::IsSection(), and title.

Referenced by Populator().

Here is the call graph for this function:

Here is the caller graph for this function:

DoEndGroup()

void CommandManager::Populator::DoEndGroup ( const MenuRegistry::GroupItem< MenuRegistry::Traits > &  item )

protected

Definition at line 300 of file CommandManager.cpp.

{
   using namespace MenuRegistry;
   auto pItem = &item;
   if (const auto pMenu = dynamic_cast<const MenuItem*>(pItem)) {
      EndMenu();
      mMenuNames.pop_back();
   }
   else
   if (const auto pConditionalGroup =
      dynamic_cast<const ConditionalGroupItem*>(pItem)
   ) {
      const bool flag = mFlags.back();
      if (!flag) {
         EndOccultCommands();
         bMakingOccultCommands = false;
      }
      mFlags.pop_back();
   }
   else
      assert(IsSection(item));
}

References flag, and MenuRegistry::IsSection().

Here is the call graph for this function:

DoSeparator()

void CommandManager::Populator::DoSeparator ( )

protected

Definition at line 424 of file CommandManager.cpp.

{
   mbSeparatorAllowed = false; // boolean to prevent too many separators.
}

DoVisit()

void CommandManager::Populator::DoVisit ( const Registry::SingleItem &  item )

protected

Definition at line 274 of file CommandManager.cpp.

{
   using namespace MenuRegistry;
   auto pItem = &item;
   if (const auto pCommand = dynamic_cast<const CommandItem*>(pItem)) {
      auto &options = pCommand->options;
      AddItem(
         pCommand->name, pCommand->label_in,
         pCommand->finder, pCommand->callback,
         pCommand->flags, options);
   }
   else
   if (const auto pCommandList = dynamic_cast<const CommandGroupItem*>(pItem)) {
      AddItemList(pCommandList->name,
         pCommandList->items.data(), pCommandList->items.size(),
         pCommandList->finder, pCommandList->callback,
         pCommandList->flags, pCommandList->isEffect);
   }
   else
      wxASSERT( false );
}

EndMenu()

void CommandManager::Populator::EndMenu ( )

protectedvirtual

Called by DoEndGroup Default implementation does nothing

Reimplemented in anonymous_namespace{MenuCreator.cpp}::MenuItemVisitor.

Definition at line 324 of file CommandManager.cpp.

{
}

EndOccultCommands()

void CommandManager::Populator::EndOccultCommands ( )

protectedvirtual

Called by DoEndGroup Default implementation does nothing

Reimplemented in anonymous_namespace{MenuCreator.cpp}::MenuItemVisitor.

Definition at line 1199 of file CommandManager.cpp.

{
}

MenuNames()

const TranslatableStrings & CommandManager::Populator::MenuNames ( ) const

inlineprotected

Stack of names of menus that were begun and not yet ended.

Definition at line 175 of file CommandManager.h.

{ return mMenuNames; }

NewIdentifier()

auto CommandManager::Populator::NewIdentifier ( const CommandID &  nameIn, const TranslatableString &  label, CommandHandlerFinder  finder, CommandFunctorPointer  callback, const CommandID &  nameSuffix, int  index, int  count, const MenuRegistry::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 445 of file CommandManager.cpp.

{
   auto &cm = Get(mProject);
 
   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 = cm.mCommandNameHash[name];
   if (prev && prev->label == label && !multi)
      return prev;
 
   {
      auto entry = AllocateEntry(options);
      assert(entry);
 
      TranslatableString labelPrefix;
      if (MenuNames().size() > 1)
         // submenus only, not main
         labelPrefix = MenuNames().back().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 = MenuNames()[0].Stripped();
      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) };
      }
 
      cm.mCommandList.push_back(std::move(entry));
      // Don't use the variable entry eny more!
   }
 
   // New variable
   CommandListEntry *entry = &*cm.mCommandList.back();
   cm.mCommandNumericIDHash[entry->id] = entry;
 
#if defined(_DEBUG)
   prev = cm.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
   cm.mCommandNameHash[entry->name] = entry;
 
   if (!entry->key.empty()) {
      cm.mCommandKeyHash[entry->key] = entry;
   }
 
   return entry;
}

References AlwaysEnabledFlag, audacity::BasicSettings::BeginGroup(), TranslatableString::Debug(), Identifier::empty(), entry, anonymous_namespace{Scrubbing.cpp}::finder, Identifier::GET(), CommandManager::Get(), gPrefs, audacity::BasicSettings::HasEntry(), CommandManager::CommandListEntry::label, label, CommandManager::mProject, TranslatableString::MSGID(), name, CommandManager::NextIdentifier(), audacity::BasicSettings::Read(), size, TranslatableString::Stripped(), and wxT().

Here is the call graph for this function:

SetMaxList()

void CommandManager::Populator::SetMaxList ( )

private

Definition at line 218 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 CommandManager::ExcludedList(), gPrefs, mMaxListOnly, audacity::BasicSettings::ReadBool(), and wxT().

Here is the call graph for this function:

VisitEntry()

void CommandManager::Populator::VisitEntry ( CommandListEntry &  entry, const MenuRegistry::Options *  options  )

protectedvirtual

Called by DoVisit Override to intercept all visits of items; default implementation is noop

Parameters

options

null if a member of a list of commands

Reimplemented in anonymous_namespace{MenuCreator.cpp}::MenuItemVisitor.

Definition at line 334 of file CommandManager.cpp.

{
}

Member Data Documentation

bMakingOccultCommands

bool CommandManager::Populator::bMakingOccultCommands { false }

private

Definition at line 219 of file CommandManager.h.

mbSeparatorAllowed

bool CommandManager::Populator::mbSeparatorAllowed { false }

protected

Definition at line 210 of file CommandManager.h.

mCurrentID

int CommandManager::Populator::mCurrentID { 17000 }

private

Definition at line 218 of file CommandManager.h.

mFlags

std::vector<bool> CommandManager::Populator::mFlags

private

Definition at line 217 of file CommandManager.h.

mMaxListOnly

std::vector<NormalizedKeyString> CommandManager::Populator::mMaxListOnly

private

Definition at line 215 of file CommandManager.h.

Referenced by SetMaxList().

mMenuNames

TranslatableStrings CommandManager::Populator::mMenuNames

private

Definition at line 216 of file CommandManager.h.

mProject

AudacityProject& CommandManager::Populator::mProject

protected

Definition at line 207 of file CommandManager.h.

---

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

• CommandManager.h
• CommandManager.cpp