PluginManager Class Reference

PluginManager maintains a list of all plug ins. That covers modules, effects, generators, analysis-effects, commands. It also has functions for shared and private configs - which need to move out. More...

#include <PluginManager.h>

Inheritance diagram for PluginManager:

Collaboration diagram for PluginManager:

Classes
class	Iterator
struct	Range

Public Member Functions
RegistryPath	GetPluginEnabledSetting (const PluginID &ID) const
RegistryPath	GetPluginEnabledSetting (const PluginDescriptor &desc) const
bool	IsPluginRegistered (const PluginPath &path, const TranslatableString *pSymbol) override
	Was the plugin registry already populated for a path (maybe from loading the config file)? More...
const PluginID &	RegisterPlugin (ModuleInterface *module) override
const PluginID &	RegisterPlugin (ModuleInterface *provider, ComponentInterface *command)
const PluginID &	RegisterPlugin (ModuleInterface *provider, EffectDefinitionInterface *effect, int type) override
void	FindFilesInPathList (const wxString &pattern, const FilePaths &pathList, FilePaths &files, bool directories=false) override
bool	HasSharedConfigGroup (const PluginID &ID, const RegistryPath &group)
bool	GetSharedConfigSubgroups (const PluginID &ID, const RegistryPath &group, RegistryPaths &subgroups) override
bool	GetSharedConfig (const PluginID &ID, const RegistryPath &group, const RegistryPath &key, wxString &value, const wxString &defval=_T("")) override
bool	GetSharedConfig (const PluginID &ID, const RegistryPath &group, const RegistryPath &key, int &value, int defval=0) override
bool	GetSharedConfig (const PluginID &ID, const RegistryPath &group, const RegistryPath &key, bool &value, bool defval=false) override
bool	GetSharedConfig (const PluginID &ID, const RegistryPath &group, const RegistryPath &key, float &value, float defval=0.0) override
bool	GetSharedConfig (const PluginID &ID, const RegistryPath &group, const RegistryPath &key, double &value, double defval=0.0) override
bool	SetSharedConfig (const PluginID &ID, const RegistryPath &group, const RegistryPath &key, const wxString &value) override
bool	SetSharedConfig (const PluginID &ID, const RegistryPath &group, const RegistryPath &key, const int &value) override
bool	SetSharedConfig (const PluginID &ID, const RegistryPath &group, const RegistryPath &key, const bool &value) override
bool	SetSharedConfig (const PluginID &ID, const RegistryPath &group, const RegistryPath &key, const float &value) override
bool	SetSharedConfig (const PluginID &ID, const RegistryPath &group, const RegistryPath &key, const double &value) override
bool	RemoveSharedConfigSubgroup (const PluginID &ID, const RegistryPath &group) override
bool	RemoveSharedConfig (const PluginID &ID, const RegistryPath &group, const RegistryPath &key) override
bool	HasPrivateConfigGroup (const PluginID &ID, const RegistryPath &group)
bool	GetPrivateConfigSubgroups (const PluginID &ID, const RegistryPath &group, RegistryPaths &subgroups) override
bool	GetPrivateConfig (const PluginID &ID, const RegistryPath &group, const RegistryPath &key, wxString &value, const wxString &defval=_T("")) override
bool	GetPrivateConfig (const PluginID &ID, const RegistryPath &group, const RegistryPath &key, int &value, int defval=0) override
bool	GetPrivateConfig (const PluginID &ID, const RegistryPath &group, const RegistryPath &key, bool &value, bool defval=false) override
bool	GetPrivateConfig (const PluginID &ID, const RegistryPath &group, const RegistryPath &key, float &value, float defval=0.0) override
bool	GetPrivateConfig (const PluginID &ID, const RegistryPath &group, const RegistryPath &key, double &value, double defval=0.0) override
bool	SetPrivateConfig (const PluginID &ID, const RegistryPath &group, const RegistryPath &key, const wxString &value) override
bool	SetPrivateConfig (const PluginID &ID, const RegistryPath &group, const RegistryPath &key, const int &value) override
bool	SetPrivateConfig (const PluginID &ID, const RegistryPath &group, const RegistryPath &key, const bool &value) override
bool	SetPrivateConfig (const PluginID &ID, const RegistryPath &group, const RegistryPath &key, const float &value) override
bool	SetPrivateConfig (const PluginID &ID, const RegistryPath &group, const RegistryPath &key, const double &value) override
bool	RemovePrivateConfigSubgroup (const PluginID &ID, const RegistryPath &group) override
bool	RemovePrivateConfig (const PluginID &ID, const RegistryPath &group, const RegistryPath &key) override
void	Initialize ()
void	Terminate ()
bool	DropFile (const wxString &fileName)
int	GetPluginCount (PluginType type)
const PluginDescriptor *	GetPlugin (const PluginID &ID) const
bool	IsPluginEnabled (const PluginID &ID)
void	EnablePlugin (const PluginID &ID, bool enable)
const ComponentInterfaceSymbol &	GetSymbol (const PluginID &ID)
ComponentInterface *	GetInstance (const PluginID &ID)
void	CheckForUpdates (bool bFast=false)
const PluginID &	RegisterPlugin (std::unique_ptr< EffectDefinitionInterface > effect, PluginType type)
	Used only by Nyquist Workbench module. More...
void	UnregisterPlugin (const PluginID &ID)
void	Load ()
	Load from preferences. More...
void	Save ()
	Save to preferences. More...
iteration over plugins of certain types, supporting range-for syntax
Range	AllPlugins ()
Range	PluginsOfType (int type)
Range	EffectsOfType (EffectType type)
Public Member Functions inherited from PluginManagerInterface
virtual	~PluginManagerInterface ()

Static Public Member Functions
static PluginManager &	Get ()
static PluginID	GetID (ModuleInterface *module)
static PluginID	GetID (ComponentInterface *command)
static PluginID	GetID (EffectDefinitionInterface *effect)
static wxString	GetPluginTypeString (PluginType type)
Static Public Member Functions inherited from PluginManagerInterface
static const PluginID &	DefaultRegistrationCallback (ModuleInterface *provider, ComponentInterface *ident)
static const PluginID &	AudacityCommandRegistrationCallback (ModuleInterface *provider, ComponentInterface *ident)

Private Member Functions
	PluginManager ()
	~PluginManager ()
void	LoadGroup (FileConfig *pRegistry, PluginType type)
void	SaveGroup (FileConfig *pRegistry, PluginType type)
PluginDescriptor &	CreatePlugin (const PluginID &id, ComponentInterface *ident, PluginType type)
FileConfig *	GetSettings ()
bool	HasGroup (const RegistryPath &group)
bool	GetSubgroups (const RegistryPath &group, RegistryPaths &subgroups)
bool	GetConfig (const RegistryPath &key, wxString &value, const wxString &defval=L"")
bool	GetConfig (const RegistryPath &key, int &value, int defval=0)
bool	GetConfig (const RegistryPath &key, bool &value, bool defval=false)
bool	GetConfig (const RegistryPath &key, float &value, float defval=0.0)
bool	GetConfig (const RegistryPath &key, double &value, double defval=0.0)
bool	SetConfig (const RegistryPath &key, const wxString &value)
bool	SetConfig (const RegistryPath &key, const int &value)
bool	SetConfig (const RegistryPath &key, const bool &value)
bool	SetConfig (const RegistryPath &key, const float &value)
bool	SetConfig (const RegistryPath &key, const double &value)
RegistryPath	SettingsPath (const PluginID &ID, bool shared)
RegistryPath	SharedGroup (const PluginID &ID, const RegistryPath &group)
RegistryPath	SharedKey (const PluginID &ID, const RegistryPath &group, const RegistryPath &key)
RegistryPath	PrivateGroup (const PluginID &ID, const RegistryPath &group)
RegistryPath	PrivateKey (const PluginID &ID, const RegistryPath &group, const RegistryPath &key)
wxString	ConvertID (const PluginID &ID)
wxString	b64encode (const void *in, int len)
int	b64decode (const wxString &in, void *out)
bool	IsDirty ()
void	SetDirty (bool dirty=true)

Private Attributes
std::unique_ptr< FileConfig >	mSettings
bool	mDirty
int	mCurrentIndex
PluginMap	mPlugins

Static Private Attributes
static std::unique_ptr< PluginManager >	mInstance {}

Detailed Description

PluginManager maintains a list of all plug ins. That covers modules, effects, generators, analysis-effects, commands. It also has functions for shared and private configs - which need to move out.

Definition at line 173 of file PluginManager.h.

Constructor & Destructor Documentation

PluginManager()

PluginManager::PluginManager ( )

private

Definition at line 673 of file PluginManager.cpp.

{
   mSettings = NULL;
}

References mSettings.

~PluginManager()

PluginManager::~PluginManager ( )

private

Definition at line 678 of file PluginManager.cpp.

{
   // Ensure termination (harmless if already done)
   Terminate();
}

References Terminate().

Here is the call graph for this function:

Member Function Documentation

AllPlugins()

Range PluginManager::AllPlugins ( )

inline

Definition at line 280 of file PluginManager.h.

{ return { Iterator{ *this } }; }

Referenced by PluginRegistrationDialog::PopulateOrExchange().

Here is the caller graph for this function:

b64decode()

int PluginManager::b64decode ( const wxString &  in, void *  out  )

private

Definition at line 2003 of file PluginManager.cpp.

{
   int len = in.length();
   unsigned char *p = (unsigned char *) out;
 
   if (len % 4)  //Sanity check
   {
      return 0;
   }
 
   int padding = 0;
   if (len)
   {
      if (in[len - 1] == padc)
      {
         padding++;
      }
 
      if (in[len - 2] == padc)
      {
         padding++;
      }
   }
 
   //const char *a = in.mb_str();
   //Setup a vector to hold the result
   unsigned long temp = 0; //Holds decoded quanta
   int i = 0;
   while (i < len)
   {
      for (int quantumPosition = 0; quantumPosition < 4; quantumPosition++)
      {
         unsigned char c = in[i];
         temp <<= 6;
 
         if (c >= 0x41 && c <= 0x5A)
         {
            temp |= c - 0x41;
         }
         else if (c >= 0x61 && c <= 0x7A)
         {
            temp |= c - 0x47;
         }
         else if (c >= 0x30 && c <= 0x39)
         {
            temp |= c + 0x04;
         }
         else if (c == 0x2B)
         {
            temp |= 0x3E;
         }
         else if (c == 0x2F)
         {
            temp |= 0x3F;
         }
         else if (c == padc)
         {
            switch (len - i)
            {
               case 1: //One pad character
                  *p++ = (temp >> 16) & 0x000000FF;
                  *p++ = (temp >> 8) & 0x000000FF;
                  return p - (unsigned char *) out;
               case 2: //Two pad characters
                  *p++ = (temp >> 10) & 0x000000FF;
                  return p - (unsigned char *) out;
            }
         }
         i++;
      }
      *p++ = (temp >> 16) & 0x000000FF;
      *p++ = (temp >> 8) & 0x000000FF;
      *p++ = temp & 0x000000FF;
   }
 
   return p - (unsigned char *) out;
}

References padc.

Referenced by ConvertID().

Here is the caller graph for this function:

b64encode()

wxString PluginManager::b64encode ( const void *  in, int  len  )

private

Definition at line 1963 of file PluginManager.cpp.

{
   unsigned char *p = (unsigned char *) in;
   wxString out;
 
   unsigned long temp;
   for (int i = 0; i < len / 3; i++)
   {
      temp  = (*p++) << 16; //Convert to big endian
      temp += (*p++) << 8;
      temp += (*p++);
      out += cset[(temp & 0x00FC0000) >> 18];
      out += cset[(temp & 0x0003F000) >> 12];
      out += cset[(temp & 0x00000FC0) >> 6];
      out += cset[(temp & 0x0000003F)];
   }
 
   switch (len % 3)
   {
      case 1:
         temp  = (*p++) << 16; //Convert to big endian
         out += cset[(temp & 0x00FC0000) >> 18];
         out += cset[(temp & 0x0003F000) >> 12];
         out += padc;
         out += padc;
      break;
 
      case 2:
         temp  = (*p++) << 16; //Convert to big endian
         temp += (*p++) << 8;
         out += cset[(temp & 0x00FC0000) >> 18];
         out += cset[(temp & 0x0003F000) >> 12];
         out += cset[(temp & 0x00000FC0) >> 6];
         out += padc;
      break;
   }
 
   return out;
}

References cset, and padc.

Referenced by ConvertID().

Here is the caller graph for this function:

CheckForUpdates()

void PluginManager::CheckForUpdates

(

bool

bFast = false

)

Definition at line 1327 of file PluginManager.cpp.

{
   ModuleManager & mm = ModuleManager::Get();
   wxArrayString pathIndex;
   for (auto &pair : mPlugins) {
      auto &plug = pair.second;
 
      // Bypass 2.1.0 placeholders...remove this after a few releases past 2.1.0
      if (plug.GetPluginType() != PluginTypeNone)
         pathIndex.push_back(plug.GetPath().BeforeFirst(wxT(';')));
   }
 
   // Check all known plugins to ensure they are still valid and scan for NEW ones.
   // 
   // All NEW plugins get a stub entry created that will remain in place until the
   // user enables or disables the plugin.
   //
   // Because we use the plugins "path" as returned by the providers, we can actually
   // have multiple providers report the same path since, at this point, they only
   // know that the path might possibly be one supported by the provider.
   //
   // When the user enables the plugin, each provider that reported it will be asked
   // to register the plugin.
   for (auto &pair : mPlugins) {
      auto &plug = pair.second;
      const PluginID & plugID = plug.GetID();
      const wxString & plugPath = plug.GetPath();
      PluginType plugType = plug.GetPluginType();
 
      // Bypass 2.1.0 placeholders...remove this after a few releases past 2.1.0
      if (plugType == PluginTypeNone)
      {
         continue;
      }
 
      if ( plugType == PluginTypeModule  )
      {
         if( bFast ) 
         {
            // Skip modules, when doing a fast refresh/check.
         } 
         else if (!mm.IsProviderValid(plugID, plugPath))
         {
            plug.SetEnabled(false);
            plug.SetValid(false);
         }
         else
         {
            // Collect plugin paths
            PluginPaths paths;
            if (auto provider = mm.CreateProviderInstance( plugID, plugPath ) )
               paths = provider->FindPluginPaths( *this );
            for (size_t i = 0, cnt = paths.size(); i < cnt; i++)
            {
               wxString path = paths[i].BeforeFirst(wxT(';'));;
               if ( ! make_iterator_range( pathIndex ).contains( path ) )
               {
                  PluginID ID = plugID + wxT("_") + path;
                  PluginDescriptor & plug2 = mPlugins[ID];  // This will create a NEW descriptor
                  plug2.SetPluginType(PluginTypeStub);
                  plug2.SetID(ID);
                  plug2.SetProviderID(plugID);
                  plug2.SetPath(path);
                  plug2.SetEnabled(false);
                  plug2.SetValid(false);
               }
            }
         }
      }
      else if (plugType != PluginTypeNone && plugType != PluginTypeStub)
      {
         plug.SetValid(mm.IsPluginValid(plug.GetProviderID(), plugPath, bFast));
         if (!plug.IsValid())
         {
            plug.SetEnabled(false);
         }
      }
   }
 
   Save();
 
   return;
}

References ModuleManager::CreateProviderInstance(), ModuleManager::Get(), ModuleManager::IsPluginValid(), ModuleManager::IsProviderValid(), make_iterator_range(), mPlugins, PluginTypeModule, PluginTypeNone, PluginTypeStub, Save(), PluginDescriptor::SetEnabled(), PluginDescriptor::SetID(), PluginDescriptor::SetPath(), PluginDescriptor::SetPluginType(), PluginDescriptor::SetProviderID(), and PluginDescriptor::SetValid().

Referenced by Initialize(), and anonymous_namespace{PluginMenus.cpp}::ShowManager().

Here is the call graph for this function:

Here is the caller graph for this function:

ConvertID()

wxString PluginManager::ConvertID ( const PluginID &  ID )

private

Definition at line 1936 of file PluginManager.cpp.

{
   if (ID.StartsWith(wxT("base64:")))
   {
      wxString id = ID.Mid(7);
      ArrayOf<char> buf{ id.length() / 4 * 3 };
      id =  wxString::FromUTF8(buf.get(), b64decode(id, buf.get()));
      return id;
   }
 
   const wxCharBuffer & buf = ID.ToUTF8();
   return wxT("base64:") + b64encode(buf, strlen(buf));
}

References b64decode(), b64encode(), and id.

Referenced by LoadGroup(), SaveGroup(), and SettingsPath().

Here is the call graph for this function:

Here is the caller graph for this function:

CreatePlugin()

PluginDescriptor & PluginManager::CreatePlugin ( const PluginID &  id, ComponentInterface *  ident, PluginType  type  )

private

Definition at line 1613 of file PluginManager.cpp.

{
   // This will either create a NEW entry or replace an existing entry
   PluginDescriptor & plug = mPlugins[id];
 
   plug.SetPluginType(type);
 
   plug.SetID(id);
   plug.SetPath(ident->GetPath());
   plug.SetSymbol(ident->GetSymbol());
   plug.SetVendor(ident->GetVendor().Internal());
   plug.SetVersion(ident->GetVersion());
 
   return plug;
}

References id, ident(), mPlugins, PluginDescriptor::SetID(), PluginDescriptor::SetPath(), PluginDescriptor::SetPluginType(), PluginDescriptor::SetSymbol(), PluginDescriptor::SetVendor(), and PluginDescriptor::SetVersion().

Referenced by RegisterPlugin().

Here is the call graph for this function:

Here is the caller graph for this function:

DropFile()

bool PluginManager::DropFile

(

const wxString &

fileName

)

Definition at line 754 of file PluginManager.cpp.

{
   auto &mm = ModuleManager::Get();
   const wxFileName src{ fileName };
 
   for (auto &plug : PluginsOfType(PluginTypeModule)) {
      auto module = static_cast<ModuleInterface *>
         (mm.CreateProviderInstance(plug.GetID(), plug.GetPath()));
      if (! module)
         continue;
 
      const auto &ff = module->InstallPath();
      const auto &extensions = module->GetFileExtensions();
      if ( !ff.empty() &&
          extensions.Index(src.GetExt(), false) != wxNOT_FOUND ) {
         TranslatableString errMsg;
         // Do dry-run test of the file format
         unsigned nPlugIns =
            module->DiscoverPluginsAtPath(fileName, errMsg, {});
         if (nPlugIns) {
            // File contents are good for this module, so check no others.
            // All branches of this block return true, even in case of
            // failure for other reasons, to signal that other drag-and-drop
            // actions should not be tried.
 
            // Find path to copy it
            wxFileName dst;
            dst.AssignDir( ff );
            dst.SetFullName( src.GetFullName() );
            if ( dst.Exists() ) {
               // Query whether to overwrite
               bool overwrite = (wxYES == ::AudacityMessageBox(
                  XO("Overwrite the plug-in file %s?")
                     .Format( dst.GetFullPath() ),
                  XO("Plug-in already exists"),
                  wxYES_NO ) );
               if ( !overwrite )
                  return true;
            }
 
            // Move the file or subtree
            bool copied = false;
            auto dstPath = dst.GetFullPath();
            if ( src.FileExists() )
               // A simple one-file plug-in
               copied = FileNames::DoCopyFile(
                  src.GetFullPath(), dstPath, true );
            else {
               // A sub-folder
               // such as for some VST packages
               // Recursive copy needed -- to do
               return true;
            }
 
            if (!copied) {
               ::AudacityMessageBox(
                  XO("Plug-in file is in use. Failed to overwrite") );
               return true;
            }
 
            // Register for real
            std::vector<PluginID> ids;
            std::vector<wxString> names;
            nPlugIns = module->DiscoverPluginsAtPath(dstPath, errMsg,
               [&](ModuleInterface *provider, ComponentInterface *ident)
                                                     -> const PluginID& {
                  // Register as by default, but also collecting the PluginIDs
                  // and names
                  auto &id = PluginManagerInterface::DefaultRegistrationCallback(
                        provider, ident);
                  ids.push_back(id);
                  names.push_back( ident->GetSymbol().Translation() );
                  return id;
               });
            if ( ! nPlugIns ) {
               // Unlikely after the dry run succeeded
               ::AudacityMessageBox(
                  XO("Failed to register:\n%s").Format( errMsg ) );
               return true;
            }
 
            // Ask whether to enable the plug-ins
            if (auto nIds = ids.size()) {
               auto message = XPC(
               /* i18n-hint A plug-in is an optional added program for a sound
                effect, or generator, or analyzer */
                  "Enable this plug-in?\n",
                  "Enable these plug-ins?\n",
                  0,
                  "plug-ins"
               )( nIds );
               for (const auto &name : names)
                  message.Join( Verbatim( name ), wxT("\n") );
               bool enable = (wxYES == ::AudacityMessageBox(
                  message,
                  XO("Enable new plug-ins"),
                  wxYES_NO ) );
               for (const auto &id : ids)
                  mPlugins[id].SetEnabled(enable);
               // Make changes to enabled status persist:
               this->Save();
            }
 
            return true;
         }
      }
   }
   
   return false;
}

References AudacityMessageBox(), PluginManagerInterface::DefaultRegistrationCallback(), FileNames::DoCopyFile(), ModuleManager::Get(), id, ident(), ModuleInterface::InstallPath(), mPlugins, name, names, PluginsOfType(), PluginTypeModule, Save(), Verbatim(), XO, and XPC.

Here is the call graph for this function:

EffectsOfType()

Range PluginManager::EffectsOfType ( EffectType  type )

inline

Definition at line 282 of file PluginManager.h.

{ return { Iterator{ *this, type } }; }

Referenced by anonymous_namespace{PluginMenus.cpp}::PopulateEffectsMenu().

Here is the caller graph for this function:

EnablePlugin()

void PluginManager::EnablePlugin	(	const PluginID &	ID,
		bool	enable
	)

Definition at line 1514 of file PluginManager.cpp.

{
   if (auto iter = mPlugins.find(ID); iter == mPlugins.end())
      return;
   else
      iter->second.SetEnabled(enable);
}

References mPlugins.

FindFilesInPathList()

void PluginManager::FindFilesInPathList ( const wxString &  pattern, const FilePaths &  pathList, FilePaths &  files, bool  directories = false  )

overridevirtual

Implements PluginManagerInterface.

Definition at line 439 of file PluginManager.cpp.

{
   
   wxLogNull nolog;
 
   // Why bother...
   if (pattern.empty())
   {
      return;
   }
 
   // TODO:  We REALLY need to figure out the "Audacity" plug-in path(s)
 
   FilePaths paths;
 
   // Add the "per-user" plug-ins directory
   {
      const wxFileName &ff = FileNames::PlugInDir();
      paths.push_back(ff.GetFullPath());
   }
 
   // Add the "Audacity" plug-ins directory
   wxFileName ff = PlatformCompatibility::GetExecutablePath();
#if defined(__WXMAC__)
   // Path ends for example in "Audacity.app/Contents/MacOSX"
   //ff.RemoveLastDir();
   //ff.RemoveLastDir();
   // just remove the MacOSX part.
   ff.RemoveLastDir();
#endif
   ff.AppendDir(wxT("plug-ins"));
   paths.push_back(ff.GetPath());
 
   // Weed out duplicates
   for (const auto &filePath : pathList)
   {
      ff = filePath;
      const wxString path{ ff.GetFullPath() };
      if (paths.Index(path, wxFileName::IsCaseSensitive()) == wxNOT_FOUND)
      {
         paths.push_back(path);
      }
   }
 
   // Find all matching files in each path
   for (size_t i = 0, cnt = paths.size(); i < cnt; i++)
   {
      ff = paths[i] + wxFILE_SEP_PATH + pattern;
      wxDir::GetAllFiles(ff.GetPath(), &files, ff.GetFullName(), directories ? wxDIR_DEFAULT : wxDIR_FILES);
   }
 
   return;
}

References PlatformCompatibility::GetExecutablePath(), and FileNames::PlugInDir().

Here is the call graph for this function:

Get()

PluginManager & PluginManager::Get ( )

static

Definition at line 695 of file PluginManager.cpp.

{
   if (!mInstance)
   {
      mInstance.reset(safenew PluginManager);
   }
 
   return *mInstance;
}

References mInstance, and safenew.

Referenced by anonymous_namespace{PluginMenus.cpp}::AddEffectMenuItemGroup(), MacroCommands::ApplyEffectCommand(), PluginManagerInterface::AudacityCommandRegistrationCallback(), PluginManagerInterface::DefaultRegistrationCallback(), MacroCommands::DoAudacityCommand(), EffectUI::DoEffect(), anonymous_namespace{PluginMenus.cpp}::DoManagePluginsMenu(), EffectManager::GetAudacityCommand(), EffectManager::GetCommandIdentifier(), EffectManager::GetCommandSymbol(), EffectManager::GetEffect(), EffectManager::GetEffectByIdentifier(), anonymous_namespace{EffectsPrefs.cpp}::GetModuleData(), Effect::GetPrivateConfig(), Effect::GetPrivateConfigSubgroups(), Effect::GetSharedConfig(), Effect::GetSharedConfigSubgroups(), MacroCommands::HandleTextualCommand(), Effect::HasPrivateConfigGroup(), Effect::HasSharedConfigGroup(), AudacityApp::InitPart2(), MacroCommandsCatalog::MacroCommandsCatalog(), AudacityApp::OnExit(), PluginRegistrationDialog::OnOK(), ProjectFileManager::OpenFile(), anonymous_namespace{PluginMenus.cpp}::PopulateEffectsMenu(), PluginRegistrationDialog::PopulateOrExchange(), EffectManager::RegisterEffect(), Effect::RemovePrivateConfig(), Effect::RemovePrivateConfigSubgroup(), Effect::RemoveSharedConfig(), Effect::RemoveSharedConfigSubgroup(), GetInfoCommand::SendCommands(), Effect::SetPrivateConfig(), Effect::SetSharedConfig(), EffectManager::SupportsAutomation(), anonymous_namespace{TrackMenus.cpp}::TracksMenu(), and EffectManager::UnregisterEffect().

Here is the caller graph for this function:

GetConfig() [1/5]

bool PluginManager::GetConfig ( const RegistryPath &  key, bool &  value, bool  defval = false  )

private

Definition at line 1732 of file PluginManager.cpp.

{
   bool result = false;
 
   if (!key.empty())
   {
      result = GetSettings()->Read(key, &value, defval);
   }
 
   return result;
}

References GetSettings(), and key.

Here is the call graph for this function:

GetConfig() [2/5]

bool PluginManager::GetConfig ( const RegistryPath &  key, double &  value, double  defval = 0.0  )

private

Definition at line 1760 of file PluginManager.cpp.

{
   bool result = false;
 
   if (!key.empty())
   {
      result = GetSettings()->Read(key, &value, defval);
   }
 
   return result;
}

References GetSettings(), and key.

Here is the call graph for this function:

GetConfig() [3/5]

bool PluginManager::GetConfig ( const RegistryPath &  key, float &  value, float  defval = 0.0  )

private

Definition at line 1744 of file PluginManager.cpp.

{
   bool result = false;
 
   if (!key.empty())
   {
      double dval = 0.0;
 
      result = GetSettings()->Read(key, &dval, (double) defval);
 
      value = (float) dval;
   }
 
   return result;
}

References GetSettings(), and key.

Here is the call graph for this function:

GetConfig() [4/5]

bool PluginManager::GetConfig ( const RegistryPath &  key, int &  value, int  defval = 0  )

private

Definition at line 1704 of file PluginManager.cpp.

{
   bool result = false;
 
   if (!key.empty())
   {
      result = GetSettings()->Read(key, &value, defval);
   }
 
   return result;
}

References GetSettings(), and key.

Here is the call graph for this function:

GetConfig() [5/5]

bool PluginManager::GetConfig ( const RegistryPath &  key, wxString &  value, const wxString &  defval = L""  )

private

Definition at line 1716 of file PluginManager.cpp.

{
   bool result = false;
 
   if (!key.empty())
   {
      wxString wxval;
 
      result = GetSettings()->Read(key, &wxval, defval);
 
      value = wxval;
   }
 
   return result;
}

References GetSettings(), and key.

Referenced by GetPrivateConfig(), and GetSharedConfig().

Here is the call graph for this function:

Here is the caller graph for this function:

GetID() [1/3]

PluginID PluginManager::GetID ( ComponentInterface *  command )

static

Definition at line 1558 of file PluginManager.cpp.

{
   return wxString::Format(wxT("%s_%s_%s_%s_%s"),
                           GetPluginTypeString(PluginTypeAudacityCommand),
                           wxEmptyString,
                           command->GetVendor().Internal(),
                           command->GetSymbol().Internal(),
                           command->GetPath());
}

References ComponentInterface::GetPath(), GetPluginTypeString(), ComponentInterface::GetSymbol(), ComponentInterface::GetVendor(), ComponentInterfaceSymbol::Internal(), and PluginTypeAudacityCommand.

Here is the call graph for this function:

GetID() [2/3]

PluginID PluginManager::GetID ( EffectDefinitionInterface *  effect )

static

Definition at line 1568 of file PluginManager.cpp.

{
   return wxString::Format(wxT("%s_%s_%s_%s_%s"),
                           GetPluginTypeString(PluginTypeEffect),
                           effect->GetFamily().Internal(),
                           effect->GetVendor().Internal(),
                           effect->GetSymbol().Internal(),
                           effect->GetPath());
}

References EffectDefinitionInterface::GetFamily(), ComponentInterface::GetPath(), GetPluginTypeString(), ComponentInterface::GetSymbol(), ComponentInterface::GetVendor(), ComponentInterfaceSymbol::Internal(), and PluginTypeEffect.

Here is the call graph for this function:

GetID() [3/3]

PluginID PluginManager::GetID ( ModuleInterface *  module )

static

Definition at line 1553 of file PluginManager.cpp.

{
   return ModuleManager::GetID(module);
}

References ModuleManager::GetID().

Referenced by Effect::GetID(), and RegisterPlugin().

Here is the call graph for this function:

Here is the caller graph for this function:

GetInstance()

ComponentInterface * PluginManager::GetInstance

(

const PluginID &

ID

)

Definition at line 1532 of file PluginManager.cpp.

{
   if (auto iter = mPlugins.find(ID); iter == mPlugins.end())
      return nullptr;
   else {
      auto &plug = iter->second;
 
      // If not dealing with legacy effects, make sure the provider is loaded
      if (!plug.IsEffectLegacy())
      {
         const PluginID & prov = plug.GetProviderID();
         if (auto iter2 = mPlugins.find(prov); iter2 == mPlugins.end())
            return nullptr;
         else
            iter2->second.GetInstance();
      }
 
      return plug.GetInstance();
   }
}

References mPlugins.

Referenced by EffectManager::GetAudacityCommand(), and EffectManager::GetEffect().

Here is the caller graph for this function:

GetPlugin()

const PluginDescriptor * PluginManager::GetPlugin

(

const PluginID &

ID

)

const

Definition at line 1445 of file PluginManager.cpp.

{
   if (auto iter = mPlugins.find(ID); iter == mPlugins.end())
      return nullptr;
   else
      return &iter->second;
}

References mPlugins.

Referenced by anonymous_namespace{PluginMenus.cpp}::AddEffectMenuItemGroup(), MacroCommands::ApplyEffectCommand(), MacroCommands::DoAudacityCommand(), EffectUI::DoEffect(), GetPluginEnabledSetting(), EffectManager::SupportsAutomation(), and anonymous_namespace{TrackMenus.cpp}::TracksMenu().

Here is the caller graph for this function:

GetPluginCount()

int PluginManager::GetPluginCount

(

PluginType

type

)

Definition at line 1439 of file PluginManager.cpp.

{
   return count_if(mPlugins.begin(), mPlugins.end(), [type](auto &pair){
      return pair.second.GetPluginType() == type; });
}

References mPlugins.

GetPluginEnabledSetting() [1/2]

RegistryPath PluginManager::GetPluginEnabledSetting

(

const PluginDescriptor &

desc

)

const

Definition at line 360 of file PluginManager.cpp.

{
   switch ( desc.GetPluginType() ) {
      case PluginTypeModule: {
         // Retrieve optional family symbol that was recorded in
         // RegisterPlugin() for the module
         auto family = desc.GetEffectFamily();
         if ( family.empty() ) // as for built-in effect and command modules
            return {};
         else
            return wxT('/') + family + wxT("/Enable");
      }
      case PluginTypeEffect:
         // do NOT use GetEffectFamily() for this descriptor, but instead,
         // delegate to the plugin descriptor of the provider, which may
         // be different (may be empty)
         return GetPluginEnabledSetting( desc.GetProviderID() );
      default:
         return {};
   }
}

References desc, GetPluginEnabledSetting(), PluginTypeEffect, and PluginTypeModule.

Here is the call graph for this function:

GetPluginEnabledSetting() [2/2]

RegistryPath PluginManager::GetPluginEnabledSetting

(

const PluginID &

ID

)

const

Definition at line 352 of file PluginManager.cpp.

{
   auto pPlugin = GetPlugin( ID );
   if ( pPlugin )
      return GetPluginEnabledSetting( *pPlugin );
   return {};
}

References GetPlugin().

Referenced by PluginManager::Iterator::Advance(), and GetPluginEnabledSetting().

Here is the call graph for this function:

Here is the caller graph for this function:

GetPluginTypeString()

wxString PluginManager::GetPluginTypeString ( PluginType  type )

static

Definition at line 1580 of file PluginManager.cpp.

{
   wxString str;
 
   switch (type)
   {
   default:
   case PluginTypeNone:
      str = wxT("Placeholder");
      break;
   case PluginTypeStub:
      str = wxT("Stub");
      break;
   case PluginTypeEffect:
      str = wxT("Effect");
      break;
   case PluginTypeAudacityCommand:
      str = wxT("Generic");
      break;
   case PluginTypeExporter:
      str = wxT("Exporter");
      break;
   case PluginTypeImporter:
      str = wxT("Importer");
      break;
   case PluginTypeModule:
      str = ModuleManager::GetPluginTypeString();
      break;
   }
 
   return str;
}

References ModuleManager::GetPluginTypeString(), PluginTypeAudacityCommand, PluginTypeEffect, PluginTypeExporter, PluginTypeImporter, PluginTypeModule, PluginTypeNone, and PluginTypeStub.

Referenced by GetID(), Load(), LoadGroup(), SaveGroup(), and SettingsPath().

Here is the call graph for this function:

Here is the caller graph for this function:

GetPrivateConfig() [1/5]

bool PluginManager::GetPrivateConfig ( const PluginID &  ID, const RegistryPath &  group, const RegistryPath &  key, bool &  value, bool  defval = false  )

overridevirtual

Implements PluginManagerInterface.

Definition at line 598 of file PluginManager.cpp.

{
   return GetConfig(PrivateKey(ID, group, key), value, defval);
}

References GetConfig(), key, and PrivateKey().

Here is the call graph for this function:

GetPrivateConfig() [2/5]

bool PluginManager::GetPrivateConfig ( const PluginID &  ID, const RegistryPath &  group, const RegistryPath &  key, double &  value, double  defval = 0.0  )

overridevirtual

Implements PluginManagerInterface.

Definition at line 608 of file PluginManager.cpp.

{
   return GetConfig(PrivateKey(ID, group, key), value, defval);
}

References GetConfig(), key, and PrivateKey().

Here is the call graph for this function:

GetPrivateConfig() [3/5]

bool PluginManager::GetPrivateConfig ( const PluginID &  ID, const RegistryPath &  group, const RegistryPath &  key, float &  value, float  defval = 0.0  )

overridevirtual

Implements PluginManagerInterface.

Definition at line 603 of file PluginManager.cpp.

{
   return GetConfig(PrivateKey(ID, group, key), value, defval);
}

References GetConfig(), key, and PrivateKey().

Here is the call graph for this function:

GetPrivateConfig() [4/5]

bool PluginManager::GetPrivateConfig ( const PluginID &  ID, const RegistryPath &  group, const RegistryPath &  key, int &  value, int  defval = 0  )

overridevirtual

Implements PluginManagerInterface.

Definition at line 593 of file PluginManager.cpp.

{
   return GetConfig(PrivateKey(ID, group, key), value, defval);
}

References GetConfig(), key, and PrivateKey().

Here is the call graph for this function:

GetPrivateConfig() [5/5]

bool PluginManager::GetPrivateConfig ( const PluginID &  ID, const RegistryPath &  group, const RegistryPath &  key, wxString &  value, const wxString &  defval = _T("")  )

overridevirtual

Implements PluginManagerInterface.

Definition at line 588 of file PluginManager.cpp.

{
   return GetConfig(PrivateKey(ID, group, key), value, defval);
}

References GetConfig(), key, and PrivateKey().

Referenced by Effect::GetPrivateConfig().

Here is the call graph for this function:

Here is the caller graph for this function:

GetPrivateConfigSubgroups()

bool PluginManager::GetPrivateConfigSubgroups ( const PluginID &  ID, const RegistryPath &  group, RegistryPaths &  subgroups  )

overridevirtual

Implements PluginManagerInterface.

Definition at line 583 of file PluginManager.cpp.

{
   return GetSubgroups(PrivateGroup(ID, group), subgroups);
}

References GetSubgroups(), and PrivateGroup().

Referenced by Effect::GetPrivateConfigSubgroups().

Here is the call graph for this function:

Here is the caller graph for this function:

GetSettings()

FileConfig * PluginManager::GetSettings ( )

private

Definition at line 1631 of file PluginManager.cpp.

{
   if (!mSettings)
   {
      mSettings =
         AudacityFileConfig::Create({}, {}, FileNames::PluginSettings());
 
      // Check for a settings version that we can understand
      if (mSettings->HasEntry(SETVERKEY))
      {
         wxString setver = mSettings->Read(SETVERKEY, SETVERKEY);
         if (setver < SETVERCUR )
         {
            // This is where we'd put in conversion code when the
            // settings version changes.
            //
            // Should also check for a settings file that is newer than
            // what we can understand.
         }
      }
      else
      {
         // Make sure is has a version string
         mSettings->Write(SETVERKEY, SETVERCUR);
         mSettings->Flush();
      }
   }
 
   return mSettings.get();
}

References AudacityFileConfig::Create(), mSettings, FileNames::PluginSettings(), SETVERCUR, and SETVERKEY.

Referenced by GetConfig(), GetSubgroups(), HasGroup(), Initialize(), RemovePrivateConfig(), RemovePrivateConfigSubgroup(), RemoveSharedConfig(), RemoveSharedConfigSubgroup(), and SetConfig().

Here is the call graph for this function:

Here is the caller graph for this function:

GetSharedConfig() [1/5]

bool PluginManager::GetSharedConfig ( const PluginID &  ID, const RegistryPath &  group, const RegistryPath &  key, bool &  value, bool  defval = false  )

overridevirtual

Implements PluginManagerInterface.

Definition at line 516 of file PluginManager.cpp.

{
   return GetConfig(SharedKey(ID, group, key), value, defval);
}

References GetConfig(), key, and SharedKey().

Here is the call graph for this function:

GetSharedConfig() [2/5]

bool PluginManager::GetSharedConfig ( const PluginID &  ID, const RegistryPath &  group, const RegistryPath &  key, double &  value, double  defval = 0.0  )

overridevirtual

Implements PluginManagerInterface.

Definition at line 526 of file PluginManager.cpp.

{
   return GetConfig(SharedKey(ID, group, key), value, defval);
}

References GetConfig(), key, and SharedKey().

Here is the call graph for this function:

GetSharedConfig() [3/5]

bool PluginManager::GetSharedConfig ( const PluginID &  ID, const RegistryPath &  group, const RegistryPath &  key, float &  value, float  defval = 0.0  )

overridevirtual

Implements PluginManagerInterface.

Definition at line 521 of file PluginManager.cpp.

{
   return GetConfig(SharedKey(ID, group, key), value, defval);
}

References GetConfig(), key, and SharedKey().

Here is the call graph for this function:

GetSharedConfig() [4/5]

bool PluginManager::GetSharedConfig ( const PluginID &  ID, const RegistryPath &  group, const RegistryPath &  key, int &  value, int  defval = 0  )

overridevirtual

Implements PluginManagerInterface.

Definition at line 511 of file PluginManager.cpp.

{
   return GetConfig(SharedKey(ID, group, key), value, defval);
}

References GetConfig(), key, and SharedKey().

Here is the call graph for this function:

GetSharedConfig() [5/5]

bool PluginManager::GetSharedConfig ( const PluginID &  ID, const RegistryPath &  group, const RegistryPath &  key, wxString &  value, const wxString &  defval = _T("")  )

overridevirtual

Implements PluginManagerInterface.

Definition at line 506 of file PluginManager.cpp.

{
   return GetConfig(SharedKey(ID, group, key), value, defval);
}

References GetConfig(), key, and SharedKey().

Referenced by Effect::GetSharedConfig().

Here is the call graph for this function:

Here is the caller graph for this function:

GetSharedConfigSubgroups()

bool PluginManager::GetSharedConfigSubgroups ( const PluginID &  ID, const RegistryPath &  group, RegistryPaths &  subgroups  )

overridevirtual

Implements PluginManagerInterface.

Definition at line 501 of file PluginManager.cpp.

{
   return GetSubgroups(SharedGroup(ID, group), subgroups);
}

References GetSubgroups(), and SharedGroup().

Referenced by Effect::GetSharedConfigSubgroups().

Here is the call graph for this function:

Here is the caller graph for this function:

GetSubgroups()

bool PluginManager::GetSubgroups ( const RegistryPath &  group, RegistryPaths &  subgroups  )

private

Definition at line 1679 of file PluginManager.cpp.

{
   if (group.empty() || !HasGroup(group))
   {
      return false;
   }
 
   wxString path = GetSettings()->GetPath();
   GetSettings()->SetPath(group);
 
   wxString name;
   long index = 0;
   if (GetSettings()->GetFirstGroup(name, index))
   {
      do
      {
         subgroups.push_back(name);
      } while (GetSettings()->GetNextGroup(name, index));
   }
 
   GetSettings()->SetPath(path);
 
   return true;
}

References FileConfig::GetPath(), GetSettings(), HasGroup(), name, and FileConfig::SetPath().

Referenced by GetPrivateConfigSubgroups(), and GetSharedConfigSubgroups().

Here is the call graph for this function:

Here is the caller graph for this function:

GetSymbol()

const ComponentInterfaceSymbol & PluginManager::GetSymbol

(

const PluginID &

ID

)

Definition at line 1522 of file PluginManager.cpp.

{
   if (auto iter = mPlugins.find(ID); iter == mPlugins.end()) {
      static ComponentInterfaceSymbol empty;
      return empty;
   }
   else
      return iter->second.GetSymbol();
}

References mPlugins.

Referenced by EffectManager::GetCommandIdentifier(), EffectManager::GetCommandSymbol(), and ComponentInterface::GetName().

Here is the caller graph for this function:

HasGroup()

bool PluginManager::HasGroup ( const RegistryPath &  group )

private

Definition at line 1662 of file PluginManager.cpp.

{
   auto settings = GetSettings();
 
   bool res = settings->HasGroup(group);
   if (res)
   {
      // The group exists, but empty groups aren't considered valid
      wxString oldPath = settings->GetPath();
      settings->SetPath(group);
      res = settings->GetNumberOfEntries() || settings->GetNumberOfGroups();
      settings->SetPath(oldPath);
   }
 
   return res;
}

References GetSettings(), and settings().

Referenced by GetSubgroups(), HasPrivateConfigGroup(), and HasSharedConfigGroup().

Here is the call graph for this function:

Here is the caller graph for this function:

HasPrivateConfigGroup()

bool PluginManager::HasPrivateConfigGroup	(	const PluginID &	ID,
		const RegistryPath &	group
	)

Definition at line 578 of file PluginManager.cpp.

{
   return HasGroup(PrivateGroup(ID, group));
}

References HasGroup(), and PrivateGroup().

Referenced by Effect::HasPrivateConfigGroup().

Here is the call graph for this function:

Here is the caller graph for this function:

HasSharedConfigGroup()

bool PluginManager::HasSharedConfigGroup	(	const PluginID &	ID,
		const RegistryPath &	group
	)

Definition at line 496 of file PluginManager.cpp.

{
   return HasGroup(SharedGroup(ID, group));
}

References HasGroup(), and SharedGroup().

Referenced by Effect::HasSharedConfigGroup().

Here is the call graph for this function:

Here is the caller graph for this function:

Initialize()

void PluginManager::Initialize

(

)

Definition at line 705 of file PluginManager.cpp.

{
   // Always load the registry first
   Load();
 
   // And force load of setting to verify it's accessible
   GetSettings();
 
   auto &mm = ModuleManager::Get();
   mm.DiscoverProviders();
   for (const auto &[id, module] : mm.Providers()) {
      RegisterPlugin(module.get());
      // Allow the module to auto-register children
      module->AutoRegisterPlugins(*this);
   }
 
   // And finally check for updates
#ifndef EXPERIMENTAL_EFFECT_MANAGEMENT
   CheckForUpdates();
#else
   const bool kFast = true;
   CheckForUpdates( kFast );
#endif
}

References CheckForUpdates(), ModuleManager::Get(), GetSettings(), Load(), and RegisterPlugin().

Referenced by AudacityApp::InitPart2().

Here is the call graph for this function:

Here is the caller graph for this function:

IsDirty()

bool PluginManager::IsDirty ( )

private

IsPluginEnabled()

bool PluginManager::IsPluginEnabled

(

const PluginID &

ID

)

Definition at line 1506 of file PluginManager.cpp.

{
   if (auto iter = mPlugins.find(ID); iter == mPlugins.end())
      return false;
   else
      return iter->second.IsEnabled();
}

References mPlugins.

IsPluginRegistered()

bool PluginManager::IsPluginRegistered ( const PluginPath &  path, const TranslatableString *  pName  )

overridevirtual

Was the plugin registry already populated for a path (maybe from loading the config file)?

Parameters

path	an identifier for the plug-in with meaning defined by provider; not always a file path
pName	if supplied, a correction for the user visible name associated with the plug-in, if it is registered already. (Needed because the configuration file only stores an internal name.)

Implements PluginManagerInterface.

Definition at line 383 of file PluginManager.cpp.

{
   for (auto &pair : mPlugins) {
      if (auto &descriptor = pair.second; descriptor.GetPath() == path) {
         if (pName)
            descriptor.SetSymbol(
               { descriptor.GetSymbol().Internal(), *pName });
         return true;
      }
   }
   return false;
}

References Internal, and mPlugins.

Load()

void PluginManager::Load

(

)

Load from preferences.

Definition at line 865 of file PluginManager.cpp.

{
   // Create/Open the registry
   auto pRegistry = AudacityFileConfig::Create(
      {}, {}, FileNames::PluginRegistry());
   auto &registry = *pRegistry;
 
   // If this group doesn't exist then we have something that's not a registry.
   // We should probably warn the user, but it's pretty unlikely that this will happen.
   if (!registry.HasGroup(REGROOT))
   {
      // Must start over
      // This DeleteAll affects pluginregistry.cfg only, not audacity.cfg
      // That is, the memory of on/off states of effect (and generator,
      // analyzer, and tool) plug-ins
      registry.DeleteAll();
      registry.Flush();
      return;
   }
 
   // Check for a registry version that we can understand
   // TODO: Should also check for a registry file that is newer than
   // what we can understand.
   wxString regver = registry.Read(REGVERKEY);
   if (regver < REGVERCUR )
   {
      // Conversion code here, for when registry version changes.
 
      // We iterate through the effects, possibly updating their info.
      wxString groupName;
      long groupIndex;
      wxString group = GetPluginTypeString(PluginTypeEffect);
      wxString cfgPath = REGROOT + group + wxCONFIG_PATH_SEPARATOR;
      wxArrayString groupsToDelete;
 
      registry.SetPath(cfgPath);
      for (bool cont = registry.GetFirstGroup(groupName, groupIndex);
         cont;
         registry.SetPath(cfgPath),
         cont = registry.GetNextGroup(groupName, groupIndex))
      {
         registry.SetPath(groupName);
         wxString effectSymbol = registry.Read(KEY_SYMBOL, "");
         wxString effectVersion = registry.Read(KEY_VERSION, "");
 
 
         // For 2.3.0 the plugins we distribute have moved around.
         // So we upped the registry version number to 1.1.
         // These particular config edits were originally written to fix Bug 1914.
         if (regver <= "1.0") {
            // Nyquist prompt is a built-in that has moved to the tools menu.
            if (effectSymbol == NYQUIST_PROMPT_ID) {
               registry.Write(KEY_EFFECTTYPE, "Tool");
            // Old version of SDE was in Analyze menu.  Now it is in Tools.
            // We don't want both the old and the new.
            } else if ((effectSymbol == "Sample Data Export") && (effectVersion == "n/a")) {
               groupsToDelete.push_back(cfgPath + groupName);
            // Old version of SDI was in Generate menu.  Now it is in Tools.
            } else if ((effectSymbol == "Sample Data Import") && (effectVersion == "n/a")) {
               groupsToDelete.push_back(cfgPath + groupName);
            }
         }
 
      }
      // Doing the deletion within the search loop risked skipping some items,
      // hence the delayed delete.
      for (unsigned int i = 0; i < groupsToDelete.size(); i++) {
         registry.DeleteGroup(groupsToDelete[i]);
      }
      registry.SetPath("");
      registry.Write(REGVERKEY, REGVERCUR);
      // Updates done.  Make sure we read the updated data later.
      registry.Flush();
   }
 
   // Load all provider plugins first
   LoadGroup(&registry, PluginTypeModule);
 
   // Now the rest
   LoadGroup(&registry, PluginTypeEffect);
   LoadGroup(&registry, PluginTypeAudacityCommand );
   LoadGroup(&registry, PluginTypeExporter);
   LoadGroup(&registry, PluginTypeImporter);
 
   LoadGroup(&registry, PluginTypeStub);
   return;
}

References AudacityFileConfig::Create(), GetPluginTypeString(), KEY_EFFECTTYPE, KEY_SYMBOL, KEY_VERSION, LoadGroup(), NYQUIST_PROMPT_ID, FileNames::PluginRegistry(), PluginTypeAudacityCommand, PluginTypeEffect, PluginTypeExporter, PluginTypeImporter, PluginTypeModule, PluginTypeStub, REGROOT, REGVERCUR, and REGVERKEY.

Referenced by Initialize().

Here is the call graph for this function:

Here is the caller graph for this function:

LoadGroup()

void PluginManager::LoadGroup ( FileConfig *  pRegistry, PluginType  type  )

private

Definition at line 953 of file PluginManager.cpp.

{
#ifdef __WXMAC__
   // Bug 1590: On Mac, we should purge the registry of Nyquist plug-ins
   // bundled with other versions of Audacity, assuming both versions
   // were properly installed in /Applications (or whatever it is called in
   // your locale)
 
   const auto fullExePath = PlatformCompatibility::GetExecutablePath();
 
   // Strip rightmost path components up to *.app
   wxFileName exeFn{ fullExePath };
   exeFn.SetEmptyExt();
   exeFn.SetName(wxString{});
   while(exeFn.GetDirCount() && !exeFn.GetDirs().back().EndsWith(".app"))
      exeFn.RemoveLastDir();
 
   const auto goodPath = exeFn.GetPath();
 
   if(exeFn.GetDirCount())
      exeFn.RemoveLastDir();
   const auto possiblyBadPath = exeFn.GetPath();
 
   auto AcceptPath = [&](const wxString &path) {
      if (!path.StartsWith(possiblyBadPath))
         // Assume it's not under /Applications
         return true;
      if (path.StartsWith(goodPath))
         // It's bundled with this executable
         return true;
      return false;
   };
#else
   auto AcceptPath = [](const wxString&){ return true; };
#endif
 
   wxString strVal;
   bool boolVal;
   wxString groupName;
   long groupIndex;
   wxString group = GetPluginTypeString(type);
   wxString cfgPath = REGROOT + group + wxCONFIG_PATH_SEPARATOR;
 
   pRegistry->SetPath(cfgPath);
   for (bool cont = pRegistry->GetFirstGroup(groupName, groupIndex);
        cont;
        pRegistry->SetPath(cfgPath),
        cont = pRegistry->GetNextGroup(groupName, groupIndex))
   {
      PluginDescriptor plug;
 
      pRegistry->SetPath(groupName);
 
      groupName = ConvertID(groupName);
 
      // Bypass group if the ID is already in use
      if (mPlugins.count(groupName))
         continue;
 
      // Set the ID and type
      plug.SetID(groupName);
      plug.SetPluginType(type);
 
      // Get the provider ID and bypass group if not found
      if (!pRegistry->Read(KEY_PROVIDERID, &strVal, wxEmptyString))
      {
         // Bypass group if the provider isn't valid
         if (!strVal.empty() && !mPlugins.count(strVal))
            continue;
      }
      plug.SetProviderID(PluginID(strVal));
 
      // Get the path (optional)
      pRegistry->Read(KEY_PATH, &strVal, wxEmptyString);
      if (!AcceptPath(strVal))
         // Ignore the obsolete path in the config file, during session,
         // but don't remove it from the file.  Maybe you really want to
         // switch back to the other version of Audacity and lose nothing.
         continue;
      plug.SetPath(strVal);
 
      /*
       // PRL: Ignore names  written in configs before 2.3.0!
       // use Internal string only!  Let the present version of Audacity map
       // that to a user-visible string.
      // Get the name and bypass group if not found
      if (!pRegistry->Read(KEY_NAME, &strVal))
      {
         continue;
      }
      plug.SetName(strVal);
       */
 
      // Get the symbol...Audacity 2.3.0 or later requires it
      // bypass group if not found
      // Note, KEY_SYMBOL started getting written to config files in 2.1.0.
      // KEY_NAME (now ignored) was written before that, but only for VST
      // effects.
      if (!pRegistry->Read(KEY_SYMBOL, &strVal))
         continue;
 
      // Related to Bug2778: config file only remembered an internal name,
      // so this symbol may not contain the correct TranslatableString.
      // See calls to IsPluginRegistered which can correct that.
      plug.SetSymbol(strVal);
 
      // Get the version and bypass group if not found
      if (!pRegistry->Read(KEY_VERSION, &strVal))
      {
         continue;
      }
      plug.SetVersion(strVal);
 
      // Get the vendor and bypass group if not found
      if (!pRegistry->Read(KEY_VENDOR, &strVal))
      {
         continue;
      }
      plug.SetVendor( strVal );
 
#if 0
      // This was done before version 2.2.2, but the value was not really used
      // But absence of a value will cause early versions to skip the group
      // Therefore we still write a blank to keep pluginregistry.cfg
      // backwards-compatible
 
      // Get the description and bypass group if not found
      if (!pRegistry->Read(KEY_DESCRIPTION, &strVal))
      {
         continue;
      }
#endif
 
      // Is it enabled...default to no if not found
      pRegistry->Read(KEY_ENABLED, &boolVal, false);
      plug.SetEnabled(boolVal);
 
      // Is it valid...default to no if not found
      pRegistry->Read(KEY_VALID, &boolVal, false);
      plug.SetValid(boolVal);
 
      switch (type)
      {
         case PluginTypeModule:
         {
            // Nothing to do here yet
         }
         break;
 
         case PluginTypeEffect:
         {
            // Get the effect type and bypass group if not found
            if (!pRegistry->Read(KEY_EFFECTTYPE, &strVal))
               continue;
 
            if (strVal == KEY_EFFECTTYPE_NONE)
               plug.SetEffectType(EffectTypeNone);
            else if (strVal == KEY_EFFECTTYPE_ANALYZE)
               plug.SetEffectType(EffectTypeAnalyze);
            else if (strVal == KEY_EFFECTTYPE_GENERATE)
               plug.SetEffectType(EffectTypeGenerate);
            else if (strVal == KEY_EFFECTTYPE_PROCESS)
               plug.SetEffectType(EffectTypeProcess);
            else if (strVal == KEY_EFFECTTYPE_TOOL)
               plug.SetEffectType(EffectTypeTool);
            else if (strVal == KEY_EFFECTTYPE_HIDDEN)
               plug.SetEffectType(EffectTypeHidden);
            else
               continue;
 
            // Get the effect family and bypass group if not found
            if (!pRegistry->Read(KEY_EFFECTFAMILY, &strVal))
            {
               continue;
            }
            plug.SetEffectFamily(strVal);
 
            // Is it a default (above the line) effect and bypass group if not found
            if (!pRegistry->Read(KEY_EFFECTDEFAULT, &boolVal))
            {
               continue;
            }
            plug.SetEffectDefault(boolVal);
 
            // Is it an interactive effect and bypass group if not found
            if (!pRegistry->Read(KEY_EFFECTINTERACTIVE, &boolVal))
            {
               continue;
            }
            plug.SetEffectInteractive(boolVal);
 
            // Is it a realtime capable effect and bypass group if not found
            if (!pRegistry->Read(KEY_EFFECTREALTIME, &boolVal))
            {
               continue;
            }
            plug.SetEffectRealtime(boolVal);
 
            // Does the effect support automation...bypass group if not found
            if (!pRegistry->Read(KEY_EFFECTAUTOMATABLE, &boolVal))
            {
               continue;
            }
            plug.SetEffectAutomatable(boolVal);
         }
         break;
 
         case PluginTypeImporter:
         {
            // Get the importer identifier and bypass group if not found
            if (!pRegistry->Read(KEY_IMPORTERIDENT, &strVal))
            {
               continue;
            }
            plug.SetImporterIdentifier(strVal);
 
            // Get the importer extensions and bypass group if not found
            if (!pRegistry->Read(KEY_IMPORTEREXTENSIONS, &strVal))
            {
               continue;
            }
            FileExtensions extensions;
            wxStringTokenizer tkr(strVal, wxT(":"));
            while (tkr.HasMoreTokens())
            {
               extensions.push_back(tkr.GetNextToken());
            }
            plug.SetImporterExtensions(extensions);
         }
         break;
 
         case PluginTypeStub:
         {
            // Nothing additional for stubs
         }
         break;
 
         // Not used by 2.1.1 or greater and should be removed after a few releases past 2.1.0.
         case PluginTypeNone:
         {
            // Used for stub groups
         }
         break;
 
         default:
         {
            continue;
         }
      }
 
      // Everything checked out...accept the plugin
      mPlugins[groupName] = std::move(plug);
   }
 
   return;
}

References ConvertID(), EffectTypeAnalyze, EffectTypeGenerate, EffectTypeHidden, EffectTypeNone, EffectTypeProcess, EffectTypeTool, PlatformCompatibility::GetExecutablePath(), FileConfig::GetFirstGroup(), FileConfig::GetNextGroup(), GetPluginTypeString(), KEY_DESCRIPTION, KEY_EFFECTAUTOMATABLE, KEY_EFFECTDEFAULT, KEY_EFFECTFAMILY, KEY_EFFECTINTERACTIVE, KEY_EFFECTREALTIME, KEY_EFFECTTYPE, KEY_EFFECTTYPE_ANALYZE, KEY_EFFECTTYPE_GENERATE, KEY_EFFECTTYPE_HIDDEN, KEY_EFFECTTYPE_NONE, KEY_EFFECTTYPE_PROCESS, KEY_EFFECTTYPE_TOOL, KEY_ENABLED, KEY_IMPORTEREXTENSIONS, KEY_IMPORTERIDENT, KEY_PATH, KEY_PROVIDERID, KEY_SYMBOL, KEY_VALID, KEY_VENDOR, KEY_VERSION, mPlugins, PluginTypeEffect, PluginTypeImporter, PluginTypeModule, PluginTypeNone, PluginTypeStub, REGROOT, PluginDescriptor::SetEffectAutomatable(), PluginDescriptor::SetEffectDefault(), PluginDescriptor::SetEffectFamily(), PluginDescriptor::SetEffectInteractive(), PluginDescriptor::SetEffectRealtime(), PluginDescriptor::SetEffectType(), PluginDescriptor::SetEnabled(), PluginDescriptor::SetID(), PluginDescriptor::SetImporterExtensions(), PluginDescriptor::SetImporterIdentifier(), PluginDescriptor::SetPath(), FileConfig::SetPath(), PluginDescriptor::SetPluginType(), PluginDescriptor::SetProviderID(), PluginDescriptor::SetSymbol(), PluginDescriptor::SetValid(), PluginDescriptor::SetVendor(), and PluginDescriptor::SetVersion().

Referenced by Load().

Here is the call graph for this function:

Here is the caller graph for this function:

PluginsOfType()

Range PluginManager::PluginsOfType ( int  type )

inline

Definition at line 281 of file PluginManager.h.

{ return { Iterator{ *this, type } }; }

Referenced by DropFile(), EffectManager::GetEffectByIdentifier(), MacroCommandsCatalog::MacroCommandsCatalog(), and GetInfoCommand::SendCommands().

Here is the caller graph for this function:

PrivateGroup()

RegistryPath PluginManager::PrivateGroup ( const PluginID &  ID, const RegistryPath &  group  )

private

Definition at line 1909 of file PluginManager.cpp.

{
   auto path = SettingsPath(ID, false);
 
   wxFileName ff(group);
   if (!ff.GetName().empty())
   {
      path += ff.GetFullPath(wxPATH_UNIX) + wxCONFIG_PATH_SEPARATOR;
   }
 
   return path;
}

References SettingsPath().

Referenced by GetPrivateConfigSubgroups(), HasPrivateConfigGroup(), PrivateKey(), and RemovePrivateConfigSubgroup().

Here is the call graph for this function:

Here is the caller graph for this function:

PrivateKey()

RegistryPath PluginManager::PrivateKey ( const PluginID &  ID, const RegistryPath &  group, const RegistryPath &  key  )

private

Definition at line 1923 of file PluginManager.cpp.

{
   auto path = PrivateGroup(ID, group);
   if (path.empty())
   {
      return path;
   }
 
   return path + key;
}

References key, and PrivateGroup().

Referenced by GetPrivateConfig(), RemovePrivateConfig(), and SetPrivateConfig().

Here is the call graph for this function:

Here is the caller graph for this function:

RegisterPlugin() [1/4]

const PluginID & PluginManager::RegisterPlugin ( ModuleInterface *  module )

overridevirtual

Implements PluginManagerInterface.

Definition at line 397 of file PluginManager.cpp.

{
   PluginDescriptor & plug = CreatePlugin(GetID(module), module, PluginTypeModule);
   plug.SetEffectFamily(module->GetOptionalFamilySymbol().Internal());
 
   plug.SetEnabled(true);
   plug.SetValid(true);
 
   return plug.GetID();
}

References CreatePlugin(), PluginDescriptor::GetID(), GetID(), ModuleInterface::GetOptionalFamilySymbol(), ComponentInterfaceSymbol::Internal(), PluginTypeModule, PluginDescriptor::SetEffectFamily(), PluginDescriptor::SetEnabled(), and PluginDescriptor::SetValid().

Referenced by PluginManagerInterface::AudacityCommandRegistrationCallback(), PluginManagerInterface::DefaultRegistrationCallback(), Initialize(), and EffectManager::RegisterEffect().

Here is the call graph for this function:

Here is the caller graph for this function:

RegisterPlugin() [2/4]

const PluginID & PluginManager::RegisterPlugin	(	ModuleInterface *	provider,
		ComponentInterface *	command
	)

Definition at line 408 of file PluginManager.cpp.

{
   PluginDescriptor & plug = CreatePlugin(GetID(command), command, (PluginType)PluginTypeAudacityCommand);
 
   plug.SetProviderID(PluginManager::GetID(provider));
 
   plug.SetEnabled(true);
   plug.SetValid(true);
 
   return plug.GetID();
}

References CreatePlugin(), PluginDescriptor::GetID(), GetID(), PluginTypeAudacityCommand, PluginDescriptor::SetEnabled(), PluginDescriptor::SetProviderID(), and PluginDescriptor::SetValid().

Here is the call graph for this function:

RegisterPlugin() [3/4]

const PluginID & PluginManager::RegisterPlugin ( ModuleInterface *  provider, EffectDefinitionInterface *  effect, int  type  )

overridevirtual

Implements PluginManagerInterface.

Definition at line 420 of file PluginManager.cpp.

{
   PluginDescriptor & plug = CreatePlugin(GetID(effect), effect, (PluginType)type);
 
   plug.SetProviderID(PluginManager::GetID(provider));
 
   plug.SetEffectType(effect->GetClassification());
   plug.SetEffectFamily(effect->GetFamily().Internal());
   plug.SetEffectInteractive(effect->IsInteractive());
   plug.SetEffectDefault(effect->IsDefault());
   plug.SetEffectRealtime(effect->SupportsRealtime());
   plug.SetEffectAutomatable(effect->SupportsAutomation());
 
   plug.SetEnabled(true);
   plug.SetValid(true);
 
   return plug.GetID();
}

References CreatePlugin(), EffectDefinitionInterface::GetClassification(), EffectDefinitionInterface::GetFamily(), PluginDescriptor::GetID(), GetID(), ComponentInterfaceSymbol::Internal(), EffectDefinitionInterface::IsDefault(), EffectDefinitionInterface::IsInteractive(), PluginDescriptor::SetEffectAutomatable(), PluginDescriptor::SetEffectDefault(), PluginDescriptor::SetEffectFamily(), PluginDescriptor::SetEffectInteractive(), PluginDescriptor::SetEffectRealtime(), PluginDescriptor::SetEffectType(), PluginDescriptor::SetEnabled(), PluginDescriptor::SetProviderID(), PluginDescriptor::SetValid(), EffectDefinitionInterface::SupportsAutomation(), and EffectDefinitionInterface::SupportsRealtime().

Here is the call graph for this function:

RegisterPlugin() [4/4]

const PluginID & PluginManager::RegisterPlugin	(	std::unique_ptr< EffectDefinitionInterface >	effect,
		PluginType	type
	)

Used only by Nyquist Workbench module.

Definition at line 1413 of file PluginManager.cpp.

{
   PluginDescriptor & plug =
      CreatePlugin(GetID(effect.get()), effect.get(), type);
 
   plug.SetEffectType(effect->GetType());
   plug.SetEffectFamily(effect->GetFamily().Internal());
   plug.SetEffectInteractive(effect->IsInteractive());
   plug.SetEffectDefault(effect->IsDefault());
   plug.SetEffectRealtime(effect->SupportsRealtime());
   plug.SetEffectAutomatable(effect->SupportsAutomation());
 
   plug.SetInstance(std::move(effect));
   plug.SetEffectLegacy(true);
   plug.SetEnabled(true);
   plug.SetValid(true);
 
   return plug.GetID();
}

References CreatePlugin(), EffectDefinitionInterface::GetFamily(), PluginDescriptor::GetID(), GetID(), EffectDefinitionInterface::GetType(), ComponentInterfaceSymbol::Internal(), EffectDefinitionInterface::IsDefault(), EffectDefinitionInterface::IsInteractive(), PluginDescriptor::SetEffectAutomatable(), PluginDescriptor::SetEffectDefault(), PluginDescriptor::SetEffectFamily(), PluginDescriptor::SetEffectInteractive(), PluginDescriptor::SetEffectLegacy(), PluginDescriptor::SetEffectRealtime(), PluginDescriptor::SetEffectType(), PluginDescriptor::SetEnabled(), PluginDescriptor::SetInstance(), PluginDescriptor::SetValid(), EffectDefinitionInterface::SupportsAutomation(), and EffectDefinitionInterface::SupportsRealtime().

Here is the call graph for this function:

RemovePrivateConfig()

bool PluginManager::RemovePrivateConfig ( const PluginID &  ID, const RegistryPath &  group, const RegistryPath &  key  )

overridevirtual

Implements PluginManagerInterface.

Definition at line 649 of file PluginManager.cpp.

{
   bool result = GetSettings()->DeleteEntry(PrivateKey(ID, group, key));
   if (result)
   {
      GetSettings()->Flush();
   }
 
   return result;
}

References FileConfig::DeleteEntry(), FileConfig::Flush(), GetSettings(), key, and PrivateKey().

Referenced by Effect::RemovePrivateConfig().

Here is the call graph for this function:

Here is the caller graph for this function:

RemovePrivateConfigSubgroup()

bool PluginManager::RemovePrivateConfigSubgroup ( const PluginID &  ID, const RegistryPath &  group  )

overridevirtual

Implements PluginManagerInterface.

Definition at line 638 of file PluginManager.cpp.

{
   bool result = GetSettings()->DeleteGroup(PrivateGroup(ID, group));
   if (result)
   {
      GetSettings()->Flush();
   }
 
   return result;
}

References FileConfig::DeleteGroup(), FileConfig::Flush(), GetSettings(), and PrivateGroup().

Referenced by Effect::RemovePrivateConfigSubgroup().

Here is the call graph for this function:

Here is the caller graph for this function:

RemoveSharedConfig()

bool PluginManager::RemoveSharedConfig ( const PluginID &  ID, const RegistryPath &  group, const RegistryPath &  key  )

overridevirtual

Implements PluginManagerInterface.

Definition at line 567 of file PluginManager.cpp.

{
   bool result = GetSettings()->DeleteEntry(SharedKey(ID, group, key));
   if (result)
   {
      GetSettings()->Flush();
   }
 
   return result;
}

References FileConfig::DeleteEntry(), FileConfig::Flush(), GetSettings(), key, and SharedKey().

Referenced by Effect::RemoveSharedConfig().

Here is the call graph for this function:

Here is the caller graph for this function:

RemoveSharedConfigSubgroup()

bool PluginManager::RemoveSharedConfigSubgroup ( const PluginID &  ID, const RegistryPath &  group  )

overridevirtual

Implements PluginManagerInterface.

Definition at line 556 of file PluginManager.cpp.

{
   bool result = GetSettings()->DeleteGroup(SharedGroup(ID, group));
   if (result)
   {
      GetSettings()->Flush();
   }
 
   return result;
}

References FileConfig::DeleteGroup(), FileConfig::Flush(), GetSettings(), and SharedGroup().

Referenced by Effect::RemoveSharedConfigSubgroup().

Here is the call graph for this function:

Here is the caller graph for this function:

Save()

void PluginManager::Save

(

)

Save to preferences.

Definition at line 1210 of file PluginManager.cpp.

{
   // Create/Open the registry
   auto pRegistry = AudacityFileConfig::Create(
      {}, {}, FileNames::PluginRegistry());
   auto &registry = *pRegistry;
 
   // Clear pluginregistry.cfg (not audacity.cfg)
   registry.DeleteAll();
 
   // Write the version string
   registry.Write(REGVERKEY, REGVERCUR);
 
   // Save the individual groups
   SaveGroup(&registry, PluginTypeEffect);
   SaveGroup(&registry, PluginTypeExporter);
   SaveGroup(&registry, PluginTypeAudacityCommand);
   SaveGroup(&registry, PluginTypeImporter);
   SaveGroup(&registry, PluginTypeStub);
 
   // Not used by 2.1.1 or greater, but must save to allow users to switch between 2.1.0
   // and 2.1.1+.  This should be removed after a few releases past 2.1.0.
   //SaveGroup(&registry, PluginTypeNone);
 
   // And now the providers
   SaveGroup(&registry, PluginTypeModule);
 
   // Just to be safe
   registry.Flush();
}

References AudacityFileConfig::Create(), FileNames::PluginRegistry(), PluginTypeAudacityCommand, PluginTypeEffect, PluginTypeExporter, PluginTypeImporter, PluginTypeModule, PluginTypeStub, REGVERCUR, REGVERKEY, and SaveGroup().

Referenced by CheckForUpdates(), DropFile(), and PluginRegistrationDialog::OnOK().

Here is the call graph for this function:

Here is the caller graph for this function:

SaveGroup()

void PluginManager::SaveGroup ( FileConfig *  pRegistry, PluginType  type  )

private

Definition at line 1241 of file PluginManager.cpp.

{
   wxString group = GetPluginTypeString(type);
   for (auto &pair : mPlugins) {
      auto & plug = pair.second;
 
      if (plug.GetPluginType() != type)
      {
         continue;
      }
 
      pRegistry->SetPath(REGROOT + group + wxCONFIG_PATH_SEPARATOR + ConvertID(plug.GetID()));
 
      pRegistry->Write(KEY_PATH, plug.GetPath());
 
      // See comments with the corresponding load-time call to SetSymbol().
      pRegistry->Write(KEY_SYMBOL, plug.GetSymbol().Internal());
 
      // PRL:  Writing KEY_NAME which is no longer read, but older Audacity
      // versions expect to find it.
      pRegistry->Write(KEY_NAME, plug.GetSymbol().Msgid().MSGID());
 
      pRegistry->Write(KEY_VERSION, plug.GetUntranslatedVersion());
      pRegistry->Write(KEY_VENDOR, plug.GetVendor());
      // Write a blank -- see comments in LoadGroup:
      pRegistry->Write(KEY_DESCRIPTION, wxString{});
      pRegistry->Write(KEY_PROVIDERID, plug.GetProviderID());
      pRegistry->Write(KEY_ENABLED, plug.IsEnabled());
      pRegistry->Write(KEY_VALID, plug.IsValid());
 
      switch (type)
      {
         case PluginTypeModule:
         break;
 
         case PluginTypeEffect:
         {
            EffectType etype = plug.GetEffectType();
            wxString stype;
            if (etype == EffectTypeNone)
               stype = KEY_EFFECTTYPE_NONE;
            else if (etype == EffectTypeAnalyze)
               stype = KEY_EFFECTTYPE_ANALYZE;
            else if (etype == EffectTypeGenerate)
               stype = KEY_EFFECTTYPE_GENERATE;
            else if (etype == EffectTypeProcess)
               stype = KEY_EFFECTTYPE_PROCESS;
            else if (etype == EffectTypeTool)
               stype = KEY_EFFECTTYPE_TOOL;
            else if (etype == EffectTypeHidden)
               stype = KEY_EFFECTTYPE_HIDDEN;
 
            pRegistry->Write(KEY_EFFECTTYPE, stype);
            pRegistry->Write(KEY_EFFECTFAMILY, plug.GetEffectFamily());
            pRegistry->Write(KEY_EFFECTDEFAULT, plug.IsEffectDefault());
            pRegistry->Write(KEY_EFFECTINTERACTIVE, plug.IsEffectInteractive());
            pRegistry->Write(KEY_EFFECTREALTIME, plug.IsEffectRealtime());
            pRegistry->Write(KEY_EFFECTAUTOMATABLE, plug.IsEffectAutomatable());
         }
         break;
 
         case PluginTypeImporter:
         {
            pRegistry->Write(KEY_IMPORTERIDENT, plug.GetImporterIdentifier());
            const auto & extensions = plug.GetImporterExtensions();
            wxString strExt;
            for (size_t i = 0, cnt = extensions.size(); i < cnt; i++)
            {
               strExt += extensions[i] + wxT(":");
            }
            strExt.RemoveLast(1);
            pRegistry->Write(KEY_IMPORTEREXTENSIONS, strExt);
         }
         break;
 
         default:
         break;
      }
   }
 
   return;
}

References ConvertID(), EffectTypeAnalyze, EffectTypeGenerate, EffectTypeHidden, EffectTypeNone, EffectTypeProcess, EffectTypeTool, GetPluginTypeString(), KEY_DESCRIPTION, KEY_EFFECTAUTOMATABLE, KEY_EFFECTDEFAULT, KEY_EFFECTFAMILY, KEY_EFFECTINTERACTIVE, KEY_EFFECTREALTIME, KEY_EFFECTTYPE, KEY_EFFECTTYPE_ANALYZE, KEY_EFFECTTYPE_GENERATE, KEY_EFFECTTYPE_HIDDEN, KEY_EFFECTTYPE_NONE, KEY_EFFECTTYPE_PROCESS, KEY_EFFECTTYPE_TOOL, KEY_ENABLED, KEY_IMPORTEREXTENSIONS, KEY_IMPORTERIDENT, KEY_NAME, KEY_PATH, KEY_PROVIDERID, KEY_SYMBOL, KEY_VALID, KEY_VENDOR, KEY_VERSION, mPlugins, PluginTypeEffect, PluginTypeImporter, PluginTypeModule, REGROOT, and FileConfig::SetPath().

Referenced by Save().

Here is the call graph for this function:

Here is the caller graph for this function:

SetConfig() [1/5]

bool PluginManager::SetConfig ( const RegistryPath &  key, const bool &  value  )

private

Definition at line 1805 of file PluginManager.cpp.

{
   bool result = false;
 
   if (!key.empty())
   {
      result = GetSettings()->Write(key, value);
      if (result)
      {
         result = GetSettings()->Flush();
      }
   }
 
   return result;
}

References FileConfig::Flush(), GetSettings(), and key.

Here is the call graph for this function:

SetConfig() [2/5]

bool PluginManager::SetConfig ( const RegistryPath &  key, const double &  value  )

private

Definition at line 1837 of file PluginManager.cpp.

{
   bool result = false;
 
   if (!key.empty())
   {
      result = GetSettings()->Write(key, value);
      if (result)
      {
         result = GetSettings()->Flush();
      }
   }
 
   return result;
}

References FileConfig::Flush(), GetSettings(), and key.

Here is the call graph for this function:

SetConfig() [3/5]

bool PluginManager::SetConfig ( const RegistryPath &  key, const float &  value  )

private

Definition at line 1821 of file PluginManager.cpp.

{
   bool result = false;
 
   if (!key.empty())
   {
      result = GetSettings()->Write(key, value);
      if (result)
      {
         result = GetSettings()->Flush();
      }
   }
 
   return result;
}

References FileConfig::Flush(), GetSettings(), and key.

Here is the call graph for this function:

SetConfig() [4/5]

bool PluginManager::SetConfig ( const RegistryPath &  key, const int &  value  )

private

Definition at line 1789 of file PluginManager.cpp.

{
   bool result = false;
 
   if (!key.empty())
   {
      result = GetSettings()->Write(key, value);
      if (result)
      {
         result = GetSettings()->Flush();
      }
   }
 
   return result;
}

References FileConfig::Flush(), GetSettings(), and key.

Here is the call graph for this function:

SetConfig() [5/5]

bool PluginManager::SetConfig ( const RegistryPath &  key, const wxString &  value  )

private

Definition at line 1772 of file PluginManager.cpp.

{
   bool result = false;
 
   if (!key.empty())
   {
      wxString wxval = value;
      result = GetSettings()->Write(key, wxval);
      if (result)
      {
         result = GetSettings()->Flush();
      }
   }
 
   return result;
}

References FileConfig::Flush(), GetSettings(), and key.

Referenced by SetPrivateConfig(), and SetSharedConfig().

Here is the call graph for this function:

Here is the caller graph for this function:

SetDirty()

void PluginManager::SetDirty ( bool  dirty = true )

private

SetPrivateConfig() [1/5]

bool PluginManager::SetPrivateConfig ( const PluginID &  ID, const RegistryPath &  group, const RegistryPath &  key, const bool &  value  )

overridevirtual

Implements PluginManagerInterface.

Definition at line 623 of file PluginManager.cpp.

{
   return SetConfig(PrivateKey(ID, group, key), value);
}

References key, PrivateKey(), and SetConfig().

Here is the call graph for this function:

SetPrivateConfig() [2/5]

bool PluginManager::SetPrivateConfig ( const PluginID &  ID, const RegistryPath &  group, const RegistryPath &  key, const double &  value  )

overridevirtual

Implements PluginManagerInterface.

Definition at line 633 of file PluginManager.cpp.

{
   return SetConfig(PrivateKey(ID, group, key), value);
}

References key, PrivateKey(), and SetConfig().

Here is the call graph for this function:

SetPrivateConfig() [3/5]

bool PluginManager::SetPrivateConfig ( const PluginID &  ID, const RegistryPath &  group, const RegistryPath &  key, const float &  value  )

overridevirtual

Implements PluginManagerInterface.

Definition at line 628 of file PluginManager.cpp.

{
   return SetConfig(PrivateKey(ID, group, key), value);
}

References key, PrivateKey(), and SetConfig().

Here is the call graph for this function:

SetPrivateConfig() [4/5]

bool PluginManager::SetPrivateConfig ( const PluginID &  ID, const RegistryPath &  group, const RegistryPath &  key, const int &  value  )

overridevirtual

Implements PluginManagerInterface.

Definition at line 618 of file PluginManager.cpp.

{
   return SetConfig(PrivateKey(ID, group, key), value);
}

References key, PrivateKey(), and SetConfig().

Here is the call graph for this function:

SetPrivateConfig() [5/5]

bool PluginManager::SetPrivateConfig ( const PluginID &  ID, const RegistryPath &  group, const RegistryPath &  key, const wxString &  value  )

overridevirtual

Implements PluginManagerInterface.

Definition at line 613 of file PluginManager.cpp.

{
   return SetConfig(PrivateKey(ID, group, key), value);
}

References key, PrivateKey(), and SetConfig().

Referenced by Effect::SetPrivateConfig().

Here is the call graph for this function:

Here is the caller graph for this function:

SetSharedConfig() [1/5]

bool PluginManager::SetSharedConfig ( const PluginID &  ID, const RegistryPath &  group, const RegistryPath &  key, const bool &  value  )

overridevirtual

Implements PluginManagerInterface.

Definition at line 541 of file PluginManager.cpp.

{
   return SetConfig(SharedKey(ID, group, key), value);
}

References key, SetConfig(), and SharedKey().

Here is the call graph for this function:

SetSharedConfig() [2/5]

bool PluginManager::SetSharedConfig ( const PluginID &  ID, const RegistryPath &  group, const RegistryPath &  key, const double &  value  )

overridevirtual

Implements PluginManagerInterface.

Definition at line 551 of file PluginManager.cpp.

{
   return SetConfig(SharedKey(ID, group, key), value);
}

References key, SetConfig(), and SharedKey().

Here is the call graph for this function:

SetSharedConfig() [3/5]

bool PluginManager::SetSharedConfig ( const PluginID &  ID, const RegistryPath &  group, const RegistryPath &  key, const float &  value  )

overridevirtual

Implements PluginManagerInterface.

Definition at line 546 of file PluginManager.cpp.

{
   return SetConfig(SharedKey(ID, group, key), value);
}

References key, SetConfig(), and SharedKey().

Here is the call graph for this function:

SetSharedConfig() [4/5]

bool PluginManager::SetSharedConfig ( const PluginID &  ID, const RegistryPath &  group, const RegistryPath &  key, const int &  value  )

overridevirtual

Implements PluginManagerInterface.

Definition at line 536 of file PluginManager.cpp.

{
   return SetConfig(SharedKey(ID, group, key), value);
}

References key, SetConfig(), and SharedKey().

Here is the call graph for this function:

SetSharedConfig() [5/5]

bool PluginManager::SetSharedConfig ( const PluginID &  ID, const RegistryPath &  group, const RegistryPath &  key, const wxString &  value  )

overridevirtual

Implements PluginManagerInterface.

Definition at line 531 of file PluginManager.cpp.

{
   return SetConfig(SharedKey(ID, group, key), value);
}

References key, SetConfig(), and SharedKey().

Referenced by Effect::SetSharedConfig().

Here is the call graph for this function:

Here is the caller graph for this function:

SettingsPath()

RegistryPath PluginManager::SettingsPath ( const PluginID &  ID, bool  shared  )

private

Definition at line 1854 of file PluginManager.cpp.

{
   // All the strings reported by PluginDescriptor and used in this function
   // persist in the plugin settings configuration file, so they should not
   // be changed across Audacity versions, or else compatibility of the
   // configuration files will break.
 
   if (auto iter = mPlugins.find(ID); iter == mPlugins.end())
      return {};
   else {
      const PluginDescriptor & plug = iter->second;
      
      wxString id = GetPluginTypeString(plug.GetPluginType()) +
                    wxT("_") +
                    plug.GetEffectFamily() + // is empty for non-Effects
                    wxT("_") +
                    plug.GetVendor() +
                    wxT("_") +
                    (shared ? wxString{} : plug.GetSymbol().Internal());
 
      return SETROOT +
             ConvertID(id) +
             wxCONFIG_PATH_SEPARATOR +
             (shared ? wxT("shared") : wxT("private")) +
             wxCONFIG_PATH_SEPARATOR;
   }
}

References ConvertID(), PluginDescriptor::GetEffectFamily(), PluginDescriptor::GetPluginType(), GetPluginTypeString(), PluginDescriptor::GetSymbol(), PluginDescriptor::GetVendor(), ComponentInterfaceSymbol::Internal(), mPlugins, and SETROOT.

Referenced by PrivateGroup(), and SharedGroup().

Here is the call graph for this function:

Here is the caller graph for this function:

SharedGroup()

RegistryPath PluginManager::SharedGroup ( const PluginID &  ID, const RegistryPath &  group  )

private

Definition at line 1883 of file PluginManager.cpp.

{
   wxString path = SettingsPath(ID, true);
 
   wxFileName ff(group);
   if (!ff.GetName().empty())
   {
      path += ff.GetFullPath(wxPATH_UNIX) + wxCONFIG_PATH_SEPARATOR;
   }
 
   return path;
}

References SettingsPath().

Referenced by GetSharedConfigSubgroups(), HasSharedConfigGroup(), RemoveSharedConfigSubgroup(), and SharedKey().

Here is the call graph for this function:

Here is the caller graph for this function:

SharedKey()

RegistryPath PluginManager::SharedKey ( const PluginID &  ID, const RegistryPath &  group, const RegistryPath &  key  )

private

Definition at line 1897 of file PluginManager.cpp.

{
   auto path = SharedGroup(ID, group);
   if (path.empty())
   {
      return path;
   }
 
   return path + key;
}

References key, and SharedGroup().

Referenced by GetSharedConfig(), RemoveSharedConfig(), and SetSharedConfig().

Here is the call graph for this function:

Here is the caller graph for this function:

Terminate()

void PluginManager::Terminate

(

)

Definition at line 730 of file PluginManager.cpp.

{
   // Get rid of all non-module plugins first
   PluginMap::iterator iter = mPlugins.begin();
   while (iter != mPlugins.end())
   {
      PluginDescriptor & plug = iter->second;
      if (plug.GetPluginType() == PluginTypeEffect)
      {
         mPlugins.erase(iter++);
         continue;
      }
 
      ++iter;
   }
 
   // Now get rid of the modules
   iter = mPlugins.begin();
   while (iter != mPlugins.end())
   {
      mPlugins.erase(iter++);
   }
}

References PluginDescriptor::GetPluginType(), mPlugins, and PluginTypeEffect.

Referenced by AudacityApp::OnExit(), and ~PluginManager().

Here is the call graph for this function:

Here is the caller graph for this function:

UnregisterPlugin()

void PluginManager::UnregisterPlugin

(

const PluginID &

ID

)

Definition at line 1434 of file PluginManager.cpp.

{
   mPlugins.erase(ID);
}

References mPlugins.

Referenced by PluginRegistrationDialog::OnOK(), and EffectManager::UnregisterEffect().

Here is the caller graph for this function:

Member Data Documentation

mCurrentIndex

int PluginManager::mCurrentIndex

private

Definition at line 352 of file PluginManager.h.

mDirty

bool PluginManager::mDirty

private

Definition at line 351 of file PluginManager.h.

mInstance

std::unique_ptr< PluginManager > PluginManager::mInstance {}

staticprivate

Definition at line 345 of file PluginManager.h.

Referenced by Get().

mPlugins

PluginMap PluginManager::mPlugins

private

Definition at line 354 of file PluginManager.h.

Referenced by PluginManager::Iterator::Advance(), CheckForUpdates(), CreatePlugin(), DropFile(), EnablePlugin(), GetInstance(), GetPlugin(), GetPluginCount(), GetSymbol(), IsPluginEnabled(), IsPluginRegistered(), LoadGroup(), SaveGroup(), SettingsPath(), Terminate(), and UnregisterPlugin().

mSettings

std::unique_ptr<FileConfig> PluginManager::mSettings

private

Definition at line 349 of file PluginManager.h.

Referenced by GetSettings(), and PluginManager().

---

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

• PluginManager.h
• PluginManager.cpp