anonymous_namespace{MenuHelper.cpp} Namespace Reference

Classes
struct	EffectsMenuGroupsHandler
struct	MenuSectionBuilder

Typedefs
using	EffectsMenuGroups = std::vector< std::pair< TranslatableString, std::vector< TranslatableString > > >

Enumerations
enum class	GroupBy { Publisher , Type , TypePublisher }
enum class	SortBy { Name , PublisherName , TypeName }

Functions
EffectsMenuGroups	LoadEffectsMenuGroups (const wxString &path)
CommandFlag	FixBatchFlags (CommandFlag batchflags, const PluginDescriptor *plug)
void	AddEffectMenuItemGroup (MenuHelper::Group &table, const TranslatableStrings &names, const PluginIDs &plugs, const std::vector< CommandFlag > &flags, void(*onMenuCommand)(const CommandContext &))
void	AddSortedEffectMenuItems (MenuHelper::Group &table, std::vector< const PluginDescriptor * > &plugs, CommandFlag batchflags, SortBy sortBy, void(*onMenuCommand)(const CommandContext &))
auto	MakeAddGroupItems (const EffectsMenuGroups &list, CommandFlag batchflags, void(*onMenuCommand)(const CommandContext &)) -> auto
void	AddGroupedEffectMenuItems (MenuHelper::Group &table, std::vector< const PluginDescriptor * > &plugs, CommandFlag batchflags, GroupBy groupBy, void(*onMenuCommand)(const CommandContext &))
bool	CompareEffectsByName (const PluginDescriptor *a, const PluginDescriptor *b)
bool	CompareEffectsByPublisher (const PluginDescriptor *a, const PluginDescriptor *b)
bool	CompareEffectsByPublisherAndName (const PluginDescriptor *a, const PluginDescriptor *b)
bool	CompareEffectsByTypeAndName (const PluginDescriptor *a, const PluginDescriptor *b)
bool	CompareEffectsByType (const PluginDescriptor *a, const PluginDescriptor *b)
bool	ComapareEffectsByTypeAndPublisher (const PluginDescriptor *a, const PluginDescriptor *b)
bool	IsEnabledPlugin (const PluginDescriptor *plug)
bool	IsDefaultPlugin (const PluginDescriptor *plug)
bool	IsBundledPlugin (const PluginDescriptor *plug)
auto	MakeGroupsFilter (const EffectsMenuGroups &list) -> auto

Typedef Documentation

EffectsMenuGroups

using anonymous_namespace{MenuHelper.cpp}::EffectsMenuGroups = typedef std::vector<std::pair<TranslatableString, std::vector<TranslatableString> >>

Definition at line 12 of file MenuHelper.cpp.

Enumeration Type Documentation

GroupBy

enum class anonymous_namespace{MenuHelper.cpp}::GroupBy

strong

Enumerator
Publisher
Type
TypePublisher

Definition at line 23 of file MenuHelper.cpp.

{
   Publisher,
   Type,
   TypePublisher
};

SortBy

enum class anonymous_namespace{MenuHelper.cpp}::SortBy

strong

Enumerator
Name
PublisherName
TypeName

Definition at line 30 of file MenuHelper.cpp.

{
   Name,
   PublisherName,
   TypeName
};

Function Documentation

AddEffectMenuItemGroup()

void anonymous_namespace{MenuHelper.cpp}::AddEffectMenuItemGroup	(	MenuHelper::Group &	table,
		const TranslatableStrings &	names,
		const PluginIDs &	plugs,
		const std::vector< CommandFlag > &	flags,
		void(*)(const CommandContext &)	onMenuCommand
	)

Definition at line 132 of file MenuHelper.cpp.

{
   const int namesCnt = (int) names.size();
 
   int groupCnt = namesCnt;
   for (int i = 0; i < namesCnt; i++)
   {
      // compare full translations not msgids!
      while (i + 1 < namesCnt && names[i].Translation() == names[i + 1].Translation())
      {
         i++;
         groupCnt--;
      }
   }
 
   using namespace MenuRegistry;
   
   for (int i = 0; i < namesCnt; i++)
   {
      // compare full translations not msgids!
      if (i + 1 < namesCnt && names[i].Translation() == names[i + 1].Translation())
      {
         // collect a sub-menu for like-named items
         const auto name = names[i];
         const auto translation = name.Translation();
         auto subMenu = Menu("", name);
         // compare full translations not msgids!
         while (i < namesCnt && names[i].Translation() == translation)
         {
            const PluginDescriptor *plug =
               PluginManager::Get().GetPlugin(plugs[i]);
            if( plug->GetPluginType() == PluginTypeEffect )
               subMenu->push_back( Command( plug->GetID(),
                  Verbatim( plug->GetPath() ),
                  onMenuCommand,
                  flags[i],
                  Options{}
                     .IsEffect()
                     .AllowInMacros()
                     .Parameter( plugs[i] ) ) );
 
            i++;
         }
         table.push_back(move(subMenu));
         i--;
      }
      else
      {
         // collect one item
         const PluginDescriptor *plug =
            PluginManager::Get().GetPlugin(plugs[i]);
         if( plug->GetPluginType() == PluginTypeEffect )
            table.push_back( Command(
               plug->GetID(),
               names[i],
               onMenuCommand,
               flags[i],
               Options{}
                  .IsEffect()
                  .AllowInMacros()
                  .Parameter( plugs[i] ) ) );
      }
   }
}

References MenuRegistry::Options::AllowInMacros(), MenuRegistry::Command, PluginManager::Get(), PluginDescriptor::GetID(), PluginDescriptor::GetPath(), PluginManager::GetPlugin(), PluginDescriptor::GetPluginType(), MenuRegistry::Options::IsEffect(), MenuRegistry::Menu, name, names, MenuRegistry::Options::Parameter(), PluginTypeEffect, Composite::Builder< Base, Derived, BaseArgs >::push_back(), and Verbatim().

Referenced by AddGroupedEffectMenuItems(), AddSortedEffectMenuItems(), and MakeAddGroupItems().

Here is the call graph for this function:

Here is the caller graph for this function:

AddGroupedEffectMenuItems()

void anonymous_namespace{MenuHelper.cpp}::AddGroupedEffectMenuItems	(	MenuHelper::Group &	table,
		std::vector< const PluginDescriptor * > &	plugs,
		CommandFlag	batchflags,
		GroupBy	groupBy,
		void(*)(const CommandContext &)	onMenuCommand
	)

Definition at line 314 of file MenuHelper.cpp.

{
   using namespace MenuRegistry;
 
   const auto UnknownGroupName = XO("Unknown");
   auto& effectManager = EffectManager::Get();
 
   std::vector<TranslatableString> path;
 
   auto *parentTable = &table;
   std::vector<TranslatableString> names;
   PluginIDs group;
   std::vector<CommandFlag> flags;
 
   auto doAddGroup = [&]
   {
      using namespace MenuRegistry;
      if(names.empty())
         return;
 
      const auto inSubmenu = !path.empty() && (names.size() > 1);
      const auto label = inSubmenu ? path.back() : TranslatableString{};
      if (label.empty()) {
         auto items = Items("");
         AddEffectMenuItemGroup(*items, names, group, flags, onMenuCommand);
         parentTable->push_back(move(items));
      }
      else {
         auto items = Menu("", label);
         AddEffectMenuItemGroup(*items, names, group, flags, onMenuCommand);
         parentTable->push_back(move(items));
      }
 
      names.clear();
      group.clear();
      flags.clear();
   };
 
   for(auto plug : plugs)
   {
      if(groupBy == GroupBy::Publisher)
      {
         const auto vendorName = effectManager.GetVendorName(plug->GetID());
         if(path.empty() || path[0] != vendorName)
         {
            doAddGroup();
            path = { vendorName };
         }
      }
      else if(groupBy == GroupBy::Type)
      {
         const auto effectFamilyName = effectManager.GetEffectFamilyName(plug->GetID());
         if(path.empty() || path[0] != effectFamilyName)
         {
            doAddGroup();
            path = { effectFamilyName };
         }
      }
      else if(groupBy == GroupBy::TypePublisher)
      {
         const auto effectFamilyName = effectManager.GetEffectFamilyName(plug->GetID());
         const auto vendorName = effectManager.GetVendorName(plug->GetID());
         if(path.empty() || path[0] != effectFamilyName)
         {
            doAddGroup();
            path = { effectFamilyName, vendorName };
            auto menu = Menu("", effectFamilyName);
            parentTable = menu.get();
            table.push_back(move(menu));
         }
         else if(path[1] != vendorName)
         {
            doAddGroup();
            path[1] = vendorName;
         }
      }
      
      group.push_back(plug->GetID());
      names.push_back(plug->GetSymbol().Msgid());
      flags.push_back(FixBatchFlags( batchflags, plug ) );
   }
   doAddGroup();
}

References AddEffectMenuItemGroup(), TranslatableString::empty(), FixBatchFlags(), EffectManager::Get(), MenuRegistry::Items, label, MenuRegistry::Menu, names, Composite::Builder< Base, Derived, BaseArgs >::push_back(), and XO().

Referenced by MenuHelper::PopulateEffectsMenu().

Here is the call graph for this function:

Here is the caller graph for this function:

AddSortedEffectMenuItems()

void anonymous_namespace{MenuHelper.cpp}::AddSortedEffectMenuItems	(	MenuHelper::Group &	table,
		std::vector< const PluginDescriptor * > &	plugs,
		CommandFlag	batchflags,
		SortBy	sortBy,
		void(*)(const CommandContext &)	onMenuCommand
	)

Definition at line 202 of file MenuHelper.cpp.

{
   size_t pluginCnt = plugs.size();
 
   TranslatableStrings groupNames;
   PluginIDs groupPlugs;
   std::vector<CommandFlag> groupFlags;
 
   for (size_t i = 0; i < pluginCnt; i++)
   {
      const PluginDescriptor *plug = plugs[i];
 
      auto name = plug->GetSymbol().Msgid();
 
      if (plug->IsEffectInteractive())
         name += XO("...");
 
      TranslatableString group;
      if (sortBy == SortBy::PublisherName/* wxT("sortby:publisher:name")*/)
      {
         group = EffectManager::Get().GetVendorName(plug->GetID());
      }
      else if (sortBy == SortBy::TypeName /*wxT("sortby:type:name")*/)
      {
         group = EffectManager::Get().GetEffectFamilyName(plug->GetID());
      }
 
      if (plug->IsEffectDefault())
      {
         group = {};
      }
 
      groupNames.push_back(
         group.empty()
            ? name
            : XO("%s: %s").Format( group, name )
      );
 
      groupPlugs.push_back(plug->GetID());
      groupFlags.push_back(FixBatchFlags( batchflags, plug ) );
   }
 
   if (groupNames.size() > 0)
   {
      AddEffectMenuItemGroup(
         table, groupNames, groupPlugs, groupFlags,
         onMenuCommand);
   }
}

References AddEffectMenuItemGroup(), TranslatableString::empty(), FixBatchFlags(), EffectManager::Get(), EffectManager::GetEffectFamilyName(), PluginDescriptor::GetID(), PluginDescriptor::GetSymbol(), EffectManager::GetVendorName(), PluginDescriptor::IsEffectDefault(), PluginDescriptor::IsEffectInteractive(), ComponentInterfaceSymbol::Msgid(), name, and XO().

Referenced by MenuHelper::PopulateEffectsMenu().

Here is the call graph for this function:

Here is the caller graph for this function:

ComapareEffectsByTypeAndPublisher()

bool anonymous_namespace{MenuHelper.cpp}::ComapareEffectsByTypeAndPublisher	(	const PluginDescriptor *	a,
		const PluginDescriptor *	b
	)

Definition at line 491 of file MenuHelper.cpp.

{
   auto &em = EffectManager::Get();
   auto aType = em.GetEffectFamilyName(a->GetID());
   auto bType = em.GetEffectFamilyName(b->GetID());
   auto aVendor = em.GetVendorName(a->GetID());
   auto bVendor = em.GetVendorName(b->GetID());
 
   if (aType.empty())
      aType = XO("Uncategorized");
   if (bType.empty())
      bType = XO("Uncategorized");
   if (aVendor.empty())
      aVendor = XO("Unknown");
   if (bVendor.empty())
      bVendor = XO("Unknown");
 
   return
      std::make_tuple(
         aType.Translation(), aVendor.Translation(), a->GetSymbol().Translation(), a->GetPath() ) <
      std::make_tuple(
         bType.Translation(), bVendor.Translation(), b->GetSymbol().Translation(), b->GetPath() );
}

References EffectManager::Get(), PluginDescriptor::GetID(), PluginDescriptor::GetPath(), PluginDescriptor::GetSymbol(), ComponentInterfaceSymbol::Translation(), and XO().

Referenced by MenuHelper::PopulateEffectsMenu().

Here is the call graph for this function:

Here is the caller graph for this function:

CompareEffectsByName()

bool anonymous_namespace{MenuHelper.cpp}::CompareEffectsByName	(	const PluginDescriptor *	a,
		const PluginDescriptor *	b
	)

Definition at line 403 of file MenuHelper.cpp.

{
   return
      std::make_pair( a->GetSymbol().Translation(), a->GetPath() ) <
      std::make_pair( b->GetSymbol().Translation(), b->GetPath() );
}

References PluginDescriptor::GetPath(), PluginDescriptor::GetSymbol(), and ComponentInterfaceSymbol::Translation().

Referenced by MenuHelper::PopulateEffectsMenu().

Here is the call graph for this function:

Here is the caller graph for this function:

CompareEffectsByPublisher()

bool anonymous_namespace{MenuHelper.cpp}::CompareEffectsByPublisher	(	const PluginDescriptor *	a,
		const PluginDescriptor *	b
	)

Definition at line 410 of file MenuHelper.cpp.

{
   auto &em = EffectManager::Get();
   
   auto akey = em.GetVendorName(a->GetID());
   auto bkey = em.GetVendorName(b->GetID());
 
   if (akey.empty())
      akey = XO("Uncategorized");
   if (bkey.empty())
      bkey = XO("Uncategorized");
 
   return
      std::make_tuple(
         akey.Translation(), a->GetSymbol().Translation(), a->GetPath() ) <
      std::make_tuple(
         bkey.Translation(), b->GetSymbol().Translation(), b->GetPath() );
}

References EffectManager::Get(), PluginDescriptor::GetID(), PluginDescriptor::GetPath(), PluginDescriptor::GetSymbol(), ComponentInterfaceSymbol::Translation(), and XO().

Referenced by MenuHelper::PopulateEffectsMenu().

Here is the call graph for this function:

Here is the caller graph for this function:

CompareEffectsByPublisherAndName()

bool anonymous_namespace{MenuHelper.cpp}::CompareEffectsByPublisherAndName	(	const PluginDescriptor *	a,
		const PluginDescriptor *	b
	)

Definition at line 430 of file MenuHelper.cpp.

{
   auto &em = EffectManager::Get();
   auto akey = em.GetVendorName(a->GetID());
   auto bkey = em.GetVendorName(b->GetID());
 
   if (a->IsEffectDefault())
      akey = {};
   if (b->IsEffectDefault())
      bkey = {};
 
   return
      std::make_tuple(
         akey.Translation(), a->GetSymbol().Translation(), a->GetPath() ) <
      std::make_tuple(
         bkey.Translation(), b->GetSymbol().Translation(), b->GetPath() );
}

References EffectManager::Get(), PluginDescriptor::GetID(), PluginDescriptor::GetPath(), PluginDescriptor::GetSymbol(), PluginDescriptor::IsEffectDefault(), and ComponentInterfaceSymbol::Translation().

Referenced by MenuHelper::PopulateEffectsMenu().

Here is the call graph for this function:

Here is the caller graph for this function:

CompareEffectsByType()

bool anonymous_namespace{MenuHelper.cpp}::CompareEffectsByType	(	const PluginDescriptor *	a,
		const PluginDescriptor *	b
	)

Definition at line 473 of file MenuHelper.cpp.

{
   auto &em = EffectManager::Get();
   auto akey = em.GetEffectFamilyName(a->GetID());
   auto bkey = em.GetEffectFamilyName(b->GetID());
 
   if (akey.empty())
      akey = XO("Uncategorized");
   if (bkey.empty())
      bkey = XO("Uncategorized");
 
   return
      std::make_tuple(
         akey.Translation(), a->GetSymbol().Translation(), a->GetPath() ) <
      std::make_tuple(
         bkey.Translation(), b->GetSymbol().Translation(), b->GetPath() );
}

References EffectManager::Get(), PluginDescriptor::GetID(), PluginDescriptor::GetPath(), PluginDescriptor::GetSymbol(), ComponentInterfaceSymbol::Translation(), and XO().

Referenced by MenuHelper::PopulateEffectsMenu().

Here is the call graph for this function:

Here is the caller graph for this function:

CompareEffectsByTypeAndName()

bool anonymous_namespace{MenuHelper.cpp}::CompareEffectsByTypeAndName	(	const PluginDescriptor *	a,
		const PluginDescriptor *	b
	)

Definition at line 449 of file MenuHelper.cpp.

{
   auto &em = EffectManager::Get();
   auto akey = em.GetEffectFamilyName(a->GetID());
   auto bkey = em.GetEffectFamilyName(b->GetID());
 
   if (akey.empty())
      akey = XO("Uncategorized");
   if (bkey.empty())
      bkey = XO("Uncategorized");
 
   if (a->IsEffectDefault())
      akey = {};
   if (b->IsEffectDefault())
      bkey = {};
 
   return
      std::make_tuple(
         akey.Translation(), a->GetSymbol().Translation(), a->GetPath() ) <
      std::make_tuple(
         bkey.Translation(), b->GetSymbol().Translation(), b->GetPath() );
}

References EffectManager::Get(), PluginDescriptor::GetID(), PluginDescriptor::GetPath(), PluginDescriptor::GetSymbol(), PluginDescriptor::IsEffectDefault(), ComponentInterfaceSymbol::Translation(), and XO().

Here is the call graph for this function:

FixBatchFlags()

CommandFlag anonymous_namespace{MenuHelper.cpp}::FixBatchFlags	(	CommandFlag	batchflags,
		const PluginDescriptor *	plug
	)

Definition at line 124 of file MenuHelper.cpp.

{
   if ( plug->GetSymbol().Msgid() == XO( "Noise Reduction" ) )
      return ( batchflags | NoiseReductionTimeSelectedFlag() ) & ~TimeSelectedFlag();
   return batchflags;
}

References PluginDescriptor::GetSymbol(), ComponentInterfaceSymbol::Msgid(), NoiseReductionTimeSelectedFlag(), and XO().

Referenced by AddGroupedEffectMenuItems(), AddSortedEffectMenuItems(), and MakeAddGroupItems().

Here is the call graph for this function:

Here is the caller graph for this function:

IsBundledPlugin()

bool anonymous_namespace{MenuHelper.cpp}::IsBundledPlugin

(

const PluginDescriptor *

plug

)

Definition at line 532 of file MenuHelper.cpp.

{
   if(IsDefaultPlugin(plug))
      return true;
   auto applicationResourcePath = wxFileName(FileNames::ResourcesDir());
   auto pluginPath = wxFileName(plug->GetPath());
   pluginPath.MakeAbsolute();
   return pluginPath.GetPath().StartsWith(applicationResourcePath.GetPath());
}

References PluginDescriptor::GetPath(), IsDefaultPlugin(), and FileNames::ResourcesDir().

Referenced by MenuHelper::PopulateEffectsMenu().

Here is the call graph for this function:

Here is the caller graph for this function:

IsDefaultPlugin()

bool anonymous_namespace{MenuHelper.cpp}::IsDefaultPlugin

(

const PluginDescriptor *

plug

)

Definition at line 525 of file MenuHelper.cpp.

{
   if (plug->IsEffectDefault())
      return true;
   return false;
}

References PluginDescriptor::IsEffectDefault().

Referenced by IsBundledPlugin(), and MenuHelper::PopulateEffectsMenu().

Here is the call graph for this function:

Here is the caller graph for this function:

IsEnabledPlugin()

bool anonymous_namespace{MenuHelper.cpp}::IsEnabledPlugin

(

const PluginDescriptor *

plug

)

Definition at line 515 of file MenuHelper.cpp.

{
   if( PluginManager::Get().IsPluginLoaded(plug->GetID()) && EffectManager::Get().IsHidden(plug->GetID()) )
         return false;
   if ( !plug->IsEnabled() ){
      return false;// don't add to menus!
   }
   return true;
}

References EffectManager::Get(), PluginManager::Get(), PluginDescriptor::GetID(), PluginDescriptor::IsEnabled(), and EffectManager::IsHidden().

Referenced by MakeGroupsFilter(), and MenuHelper::PopulateEffectsMenu().

Here is the call graph for this function:

Here is the caller graph for this function:

LoadEffectsMenuGroups()

EffectsMenuGroups anonymous_namespace{MenuHelper.cpp}::LoadEffectsMenuGroups

(

const wxString &

path

)

Definition at line 112 of file MenuHelper.cpp.

{
   EffectsMenuGroups result;
   EffectsMenuGroupsHandler handler(result);
 
   XMLFileReader reader;
   reader.Parse(&handler, path);
   return result;
}

References audacity::cloud::audiocom::anonymous_namespace{AuthorizationHandler.cpp}::handler, and XMLFileReader::Parse().

Referenced by MenuHelper::PopulateEffectsMenu().

Here is the call graph for this function:

Here is the caller graph for this function:

MakeAddGroupItems()

auto anonymous_namespace{MenuHelper.cpp}::MakeAddGroupItems	(	const EffectsMenuGroups &	list,
		CommandFlag	batchflags,
		void(*)(const CommandContext &)	onMenuCommand
	)		-> auto

Definition at line 257 of file MenuHelper.cpp.

{
   return [=](MenuHelper::Group& items, std::vector<const PluginDescriptor*>& plugs)
   {
      for(auto& p : list)
      {
         TranslatableStrings groupNames;
         PluginIDs groupPlugs;
         std::vector<CommandFlag> groupFlags;
         
         auto srcNames = p.second;
         std::sort(srcNames.begin(), srcNames.end(), TranslationLess);
 
         for(auto& name : srcNames)
         {
            auto it = std::find_if(plugs.begin(), plugs.end(), [&name](const PluginDescriptor* other)
            {
               return name == other->GetSymbol().Msgid();
            });
            if(it == plugs.end())
               continue;
 
            auto plug = *it;
            if(plug->IsEffectInteractive())
               groupNames.push_back(name + XO("..."));
            else
               groupNames.push_back( name );
 
            groupPlugs.push_back(plug->GetID());
            groupFlags.push_back(FixBatchFlags( batchflags, plug ) );
         }
 
         if (!groupNames.empty())
         {
            using namespace MenuRegistry;
            if (p.first.empty()) {
               auto temp = Items("");
               AddEffectMenuItemGroup(*temp,
                  groupNames, groupPlugs, groupFlags,
                  onMenuCommand);
               items.push_back(move(temp));
            }
            else {
               auto temp = Menu("", p.first);
               AddEffectMenuItemGroup(*temp,
                  groupNames, groupPlugs, groupFlags,
                  onMenuCommand);
               items.push_back(move(temp));
            }
         }
      }
   };
}

References AddEffectMenuItemGroup(), FixBatchFlags(), MenuRegistry::Items, MenuRegistry::Menu, name, Composite::Builder< Base, Derived, BaseArgs >::push_back(), TranslationLess(), and XO().

Referenced by MenuHelper::PopulateEffectsMenu().

Here is the call graph for this function:

Here is the caller graph for this function:

MakeGroupsFilter()

auto anonymous_namespace{MenuHelper.cpp}::MakeGroupsFilter

(

const EffectsMenuGroups &

list

)

-> auto

Definition at line 542 of file MenuHelper.cpp.

{
   return [=](const PluginDescriptor* plug)
   {
      if(!IsEnabledPlugin(plug))
         return false;
 
      for(auto& p : list)
      {
         for(auto& name : p.second)
         {
            if(name == plug->GetSymbol().Msgid())
               return true;
         }
      }
      return false;
   };
}

References IsEnabledPlugin(), and name.

Referenced by MenuHelper::PopulateEffectsMenu().

Here is the call graph for this function:

Here is the caller graph for this function: