Audacity 3.2.0
Classes | Public Types | Public Member Functions | Static Public Member Functions | Private Member Functions | Private Attributes | Static Private Attributes | List of all members
PluginManager Class Referencefinal

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:
[legend]
Collaboration diagram for PluginManager:
[legend]

Classes

class  Iterator
 
struct  Range
 

Public Types

using FileConfigFactory = std::function< std::unique_ptr< FileConfig >(const FilePath &localFilename) >
 
- Public Types inherited from PluginManagerInterface
using ConfigurationType = PluginSettings::ConfigurationType
 
using ConfigReference = PluginSettings::ConfigReference
 
using ConfigConstReference = PluginSettings::ConfigConstReference
 

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...
 
bool IsPluginLoaded (const wxString &ID) const
 
void RegisterPlugin (PluginDescriptor &&desc)
 
const PluginIDRegisterPlugin (PluginProvider *provider) override
 
const PluginIDRegisterPlugin (PluginProvider *provider, ComponentInterface *command)
 
const PluginIDRegisterPlugin (PluginProvider *provider, EffectDefinitionInterface *effect, int type) override
 
void FindFilesInPathList (const wxString &pattern, const FilePaths &pathList, FilePaths &files, bool directories=false) override
 
bool HasConfigGroup (ConfigurationType type, const PluginID &ID, const RegistryPath &group)
 
bool GetConfigSubgroups (ConfigurationType type, const PluginID &ID, const RegistryPath &group, RegistryPaths &subgroups) override
 
bool HasConfigValue (ConfigurationType type, const PluginID &ID, const RegistryPath &group, const RegistryPath &key) override
 
bool GetConfigValue (ConfigurationType type, const PluginID &ID, const RegistryPath &group, const RegistryPath &key, ConfigReference var, ConfigConstReference defval) override
 
bool SetConfigValue (ConfigurationType type, const PluginID &ID, const RegistryPath &group, const RegistryPath &key, ConfigConstReference value) override
 
bool RemoveConfigSubgroup (ConfigurationType type, const PluginID &ID, const RegistryPath &group) override
 
bool RemoveConfig (ConfigurationType type, const PluginID &ID, const RegistryPath &group, const RegistryPath &key) override
 
void Initialize (FileConfigFactory factory)
 
void Terminate ()
 
bool DropFile (const wxString &fileName)
 
int GetPluginCount (PluginType type)
 
const PluginDescriptorGetPlugin (const PluginID &ID) const
 
bool IsPluginEnabled (const PluginID &ID)
 
void EnablePlugin (const PluginID &ID, bool enable)
 
const ComponentInterfaceSymbolGetSymbol (const PluginID &ID)
 
ComponentInterfaceLoad (const PluginID &ID)
 
void ClearEffectPlugins ()
 
std::map< wxString, std::vector< wxString > > CheckPluginUpdates ()
 Ensures that all currently registered plugins still exist and scans for new ones. More...
 
const PluginIDRegisterPlugin (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...
 
const PluginRegistryVersionGetRegistryVersion () const override
 
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 ()
 
virtual bool IsPluginRegistered (const PluginPath &path, const TranslatableString *pName=nullptr)=0
 Was the plugin registry already populated for a path (maybe from loading the config file)? More...
 
virtual const PluginIDRegisterPlugin (PluginProvider *provider)=0
 
virtual const PluginIDRegisterPlugin (PluginProvider *provider, EffectDefinitionInterface *effect, int type)=0
 
virtual void FindFilesInPathList (const wxString &pattern, const FilePaths &pathList, FilePaths &files, bool directories=false)=0
 
virtual bool GetConfigSubgroups (ConfigurationType type, const PluginID &ID, const RegistryPath &group, RegistryPaths &subgroups)=0
 
virtual bool HasConfigValue (ConfigurationType type, const PluginID &ID, const RegistryPath &group, const RegistryPath &key)=0
 
virtual bool GetConfigValue (ConfigurationType type, const PluginID &ID, const RegistryPath &group, const RegistryPath &key, ConfigReference var, ConfigConstReference defval)=0
 
virtual bool SetConfigValue (ConfigurationType type, const PluginID &ID, const RegistryPath &group, const RegistryPath &key, ConfigConstReference value)=0
 
virtual bool RemoveConfigSubgroup (ConfigurationType type, const PluginID &ID, const RegistryPath &group)=0
 
virtual bool RemoveConfig (ConfigurationType type, const PluginID &ID, const RegistryPath &group, const RegistryPath &key)=0
 
virtual const PluginRegistryVersionGetRegistryVersion () const =0
 What is the plugin registry version number now in the file? More...
 

Static Public Member Functions

static PluginManagerGet ()
 
static PluginID GetID (PluginProvider *provider)
 
static PluginID GetID (ComponentInterface *command)
 
static PluginID OldGetID (const EffectDefinitionInterface *effect)
 
static PluginID GetID (const EffectDefinitionInterface *effect)
 
static Identifier GetEffectNameFromID (const PluginID &ID)
 
static wxString GetPluginTypeString (PluginType type)
 
- Static Public Member Functions inherited from PluginManagerInterface
static const PluginIDDefaultRegistrationCallback (PluginProvider *provider, ComponentInterface *ident)
 
static const PluginIDAudacityCommandRegistrationCallback (PluginProvider *provider, ComponentInterface *ident)
 

Private Member Functions

 PluginManager ()
 
 ~PluginManager ()
 
void InitializePlugins ()
 
void LoadGroup (FileConfig *pRegistry, PluginType type)
 
void SaveGroup (FileConfig *pRegistry, PluginType type)
 
PluginDescriptorCreatePlugin (const PluginID &id, ComponentInterface *ident, PluginType type)
 
FileConfigGetSettings ()
 
bool HasGroup (const RegistryPath &group)
 
bool GetSubgroups (const RegistryPath &group, RegistryPaths &subgroups)
 
bool HasConfigValue (const RegistryPath &key)
 
bool GetConfigValue (const RegistryPath &key, ConfigReference var, ConfigConstReference defval)
 
bool SetConfigValue (const RegistryPath &key, ConfigConstReference value)
 
RegistryPath SettingsPath (ConfigurationType type, const PluginID &ID)
 
RegistryPath Group (ConfigurationType type, const PluginID &ID, const RegistryPath &group)
 
RegistryPath Key (ConfigurationType type, const PluginID &ID, const RegistryPath &group, const RegistryPath &key)
 
wxString ConvertID (const PluginID &ID)
 
bool IsDirty ()
 
void SetDirty (bool dirty=true)
 

Private Attributes

std::unique_ptr< FileConfigmSettings
 
bool mDirty
 
int mCurrentIndex
 
PluginMap mRegisteredPlugins
 
std::map< PluginID, std::unique_ptr< ComponentInterface > > mLoadedInterfaces
 
std::vector< PluginDescriptormEffectPluginsCleared
 
PluginRegistryVersion mRegver
 

Static Private Attributes

static std::unique_ptr< PluginManagermInstance {}
 

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 41 of file PluginManager.h.

Member Typedef Documentation

◆ FileConfigFactory

using PluginManager::FileConfigFactory = std::function< std::unique_ptr<FileConfig>(const FilePath &localFilename ) >

Definition at line 91 of file PluginManager.h.

Constructor & Destructor Documentation

◆ PluginManager()

PluginManager::PluginManager ( )
private

Definition at line 329 of file PluginManager.cpp.

330{
331 mSettings = NULL;
332}
std::unique_ptr< FileConfig > mSettings

References mSettings.

◆ ~PluginManager()

PluginManager::~PluginManager ( )
private

Definition at line 334 of file PluginManager.cpp.

335{
336 // Ensure termination (harmless if already done)
337 Terminate();
338}

References Terminate().

Here is the call graph for this function:

Member Function Documentation

◆ AllPlugins()

Range PluginManager::AllPlugins ( )
inline

Definition at line 146 of file PluginManager.h.

146{ return { Iterator{ *this } }; }

Referenced by PluginRegistrationDialog::PopulateItemsList().

Here is the caller graph for this function:

◆ CheckPluginUpdates()

std::map< wxString, std::vector< wxString > > PluginManager::CheckPluginUpdates ( )

Ensures that all currently registered plugins still exist and scans for new ones.

Returns
Map, where each module path(key) is associated with at least one provider id

Definition at line 1188 of file PluginManager.cpp.

1189{
1190 wxArrayString pathIndex;
1191 for (auto &pair : mRegisteredPlugins) {
1192 auto &plug = pair.second;
1193
1194 // Bypass 2.1.0 placeholders...remove this after a few releases past 2.1.0
1195 if (plug.GetPluginType() != PluginTypeNone)
1196 pathIndex.push_back(plug.GetPath().BeforeFirst(wxT(';')));
1197 }
1198
1199 // Scan for NEW ones.
1200 //
1201 // Because we use the plugins "path" as returned by the providers, we can actually
1202 // have multiple providers report the same path since, at this point, they only
1203 // know that the path might possibly be one supported by the provider.
1204 //
1205 // When the user enables the plugin, each provider that reported it will be asked
1206 // to register the plugin.
1207
1208 auto& moduleManager = ModuleManager::Get();
1209 std::map<wxString, std::vector<wxString>> newPaths;
1210 for(auto& [id, provider] : moduleManager.Providers())
1211 {
1212 const auto paths = provider->FindModulePaths(*this);
1213 for(const auto& path : paths)
1214 {
1215 const auto modulePath = path.BeforeFirst(';');
1216 if (!make_iterator_range(pathIndex).contains(modulePath) ||
1217 make_iterator_range(mEffectPluginsCleared).any_of([&modulePath](const PluginDescriptor& plug) {
1218 return plug.GetPath().BeforeFirst(wxT(';')) == modulePath;
1219 })
1220 )
1221 {
1222 newPaths[modulePath].push_back(id);
1223 }
1224 }
1225 }
1226
1227 return newPaths;
1228}
wxT("CloseDown"))
IteratorRange< Iterator > make_iterator_range(const Iterator &i1, const Iterator &i2)
Definition: MemoryX.h:431
@ PluginTypeNone
static ModuleManager & Get()
const PluginPath & GetPath() const
std::vector< PluginDescriptor > mEffectPluginsCleared
PluginMap mRegisteredPlugins

References ModuleManager::Get(), PluginDescriptor::GetPath(), make_iterator_range(), mEffectPluginsCleared, mRegisteredPlugins, PluginTypeNone, and wxT().

Referenced by AudacityApp::InitPart2(), and PluginRegistrationDialog::OnRescan().

Here is the call graph for this function:
Here is the caller graph for this function:

◆ ClearEffectPlugins()

void PluginManager::ClearEffectPlugins ( )

Definition at line 1153 of file PluginManager.cpp.

1154{
1155 mEffectPluginsCleared.clear();
1156
1157 for ( auto it = mRegisteredPlugins.cbegin(); it != mRegisteredPlugins.cend(); )
1158 {
1159 const auto& desc = it->second;
1160 const auto type = desc.GetPluginType();
1161
1162 if (type == PluginTypeEffect || type == PluginTypeStub)
1163 {
1164 mEffectPluginsCleared.push_back(desc);
1165 it = mRegisteredPlugins.erase(it);
1166 }
1167 else
1168 {
1169 ++it;
1170 }
1171 }
1172
1173 // Repeat what usually happens at startup
1174 // This prevents built-in plugins to appear in the plugin validation list
1175 for (auto& [_, provider] : ModuleManager::Get().Providers())
1176 provider->AutoRegisterPlugins(*this);
1177
1178 // Remove auto registered plugins from "cleared" list
1179 for ( auto it = mEffectPluginsCleared.begin(); it != mEffectPluginsCleared.end(); )
1180 {
1181 if ( mRegisteredPlugins.find(it->GetID()) != mRegisteredPlugins.end() )
1182 it = mEffectPluginsCleared.erase(it);
1183 else
1184 ++it;
1185 }
1186}
const TranslatableString desc
Definition: ExportPCM.cpp:58
#define _(s)
Definition: Internat.h:75
@ PluginTypeStub
@ PluginTypeEffect

References _, desc, ModuleManager::Get(), mEffectPluginsCleared, mRegisteredPlugins, PluginTypeEffect, and PluginTypeStub.

Here is the call graph for this function:

◆ ConvertID()

wxString PluginManager::ConvertID ( const PluginID ID)
private

Definition at line 1493 of file PluginManager.cpp.

1494{
1495 if (ID.StartsWith(wxT("base64:")))
1496 {
1497 wxString id = ID.Mid(7);
1498 ArrayOf<char> buf{ id.length() / 4 * 3 };
1499 id = wxString::FromUTF8(buf.get(), Base64::Decode(id, buf.get()));
1500 return id;
1501 }
1502
1503 const wxCharBuffer & buf = ID.ToUTF8();
1504 return wxT("base64:") + Base64::Encode(buf, strlen(buf));
1505}
int id
STRINGS_API wxString Encode(const void *in, int len)
Definition: Base64.cpp:27
STRINGS_API int Decode(const wxString &in, void *out)
Definition: Base64.cpp:67

References Base64::Decode(), Base64::Encode(), id, and wxT().

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 1309 of file PluginManager.cpp.

1312{
1313 // This will either create a NEW entry or replace an existing entry
1315
1316 plug.SetPluginType(type);
1317
1318 plug.SetID(id);
1319 plug.SetPath(ident->GetPath());
1320 plug.SetSymbol(ident->GetSymbol());
1321 plug.SetVendor(ident->GetVendor().Internal());
1322 plug.SetVersion(ident->GetVersion());
1323
1324 return plug;
1325}
static CommandHandlerObject & ident(AudacityProject &project)
void SetVendor(const wxString &vendor)
void SetPath(const PluginPath &path)
void SetSymbol(const ComponentInterfaceSymbol &symbol)
void SetID(const PluginID &ID)
void SetPluginType(PluginType type)
void SetVersion(const wxString &version)

References id, ident(), mRegisteredPlugins, 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 424 of file PluginManager.cpp.

425{
426 using namespace BasicUI;
427 auto &mm = ModuleManager::Get();
428 const wxFileName src{ fileName };
429
430 for (auto &plug : PluginsOfType(PluginTypeModule)) {
431 auto module = static_cast<PluginProvider *>
432 (mm.CreateProviderInstance(plug.GetID(), plug.GetPath()));
433 if (! module)
434 continue;
435
436 const auto &ff = module->InstallPath();
437 const auto &extensions = module->GetFileExtensions();
438 if ( !ff.empty() &&
439 extensions.Index(src.GetExt(), false) != wxNOT_FOUND ) {
440 TranslatableString errMsg;
441 // Do dry-run test of the file format
442 unsigned nPlugIns =
443 module->DiscoverPluginsAtPath(fileName, errMsg, {});
444 if (nPlugIns) {
445 // File contents are good for this module, so check no others.
446 // All branches of this block return true, even in case of
447 // failure for other reasons, to signal that other drag-and-drop
448 // actions should not be tried.
449
450 // Find path to copy it
451 wxFileName dst;
452 dst.AssignDir( ff );
453 dst.SetFullName( src.GetFullName() );
454 if ( dst.Exists() ) {
455 // Query whether to overwrite
456 bool overwrite = (MessageBoxResult::Yes == ShowMessageBox(
457 XO("Overwrite the plug-in file %s?")
458 .Format( dst.GetFullPath() ),
460 .Caption(XO("Plug-in already exists"))
461 .ButtonStyle(Button::YesNo)));
462 if ( !overwrite )
463 return true;
464 }
465
466 // Move the file or subtree
467 bool copied = false;
468 auto dstPath = dst.GetFullPath();
469 if ( src.FileExists() )
470 // A simple one-file plug-in
471 copied = FileNames::DoCopyFile(
472 src.GetFullPath(), dstPath, true );
473 else {
474 // A sub-folder
475 // such as for some VST packages
476 // Recursive copy needed -- to do
477 return true;
478 }
479
480 if (!copied) {
482 XO("Plug-in file is in use. Failed to overwrite") );
483 return true;
484 }
485
486 // Register for real
487 std::vector<PluginID> ids;
488 std::vector<wxString> names;
489 nPlugIns = module->DiscoverPluginsAtPath(dstPath, errMsg,
491 -> const PluginID& {
492 // Register as by default, but also collecting the PluginIDs
493 // and names
495 provider, ident);
496 ids.push_back(id);
497 names.push_back( ident->GetSymbol().Translation() );
498 return id;
499 });
500 if ( ! nPlugIns ) {
501 // Unlikely after the dry run succeeded
503 XO("Failed to register:\n%s").Format( errMsg ) );
504 return true;
505 }
506
507 // Ask whether to enable the plug-ins
508 if (auto nIds = ids.size()) {
509 auto message = XPC(
510 /* i18n-hint A plug-in is an optional added program for a sound
511 effect, or generator, or analyzer */
512 "Enable this plug-in?\n",
513 "Enable these plug-ins?\n",
514 0,
515 "plug-ins"
516 )( nIds );
517 for (const auto &name : names)
518 message.Join( Verbatim( name ), wxT("\n") );
519 bool enable = (MessageBoxResult::Yes == ShowMessageBox(
520 message,
522 .Caption(XO("Enable new plug-ins"))
523 .ButtonStyle(Button::YesNo)));
524 for (const auto &id : ids)
525 mRegisteredPlugins[id].SetEnabled(enable);
526 // Make changes to enabled status persist:
527 this->Save();
528 }
529
530 return true;
531 }
532 }
533 }
534
535 return false;
536}
const TranslatableString name
Definition: Distortion.cpp:82
wxString PluginID
Definition: EffectManager.h:30
#define XPC(sing, plur, n, c)
Definition: Internat.h:100
#define XO(s)
Definition: Internat.h:31
@ PluginTypeModule
static TranslatableStrings names
Definition: TagsEditor.cpp:151
TranslatableString Verbatim(wxString str)
Require calls to the one-argument constructor to go through this distinct global function name.
ComponentInterface provides name / vendor / version functions to identify plugins....
Abstract base class used in importing a file.
void Save()
Save to preferences.
Range PluginsOfType(int type)
static const PluginID & DefaultRegistrationCallback(PluginProvider *provider, ComponentInterface *ident)
virtual FilePath InstallPath()=0
Where plug-in files should be copied to install them.
Holds a msgid for the translation catalog; may also bind format arguments.
MessageBoxResult ShowMessageBox(const TranslatableString &message, MessageBoxOptions options={})
Show a modal message box with either Ok or Yes and No, and optionally Cancel.
Definition: BasicUI.h:269
FILES_API bool DoCopyFile(const FilePath &file1, const FilePath &file2, bool overwrite=true)
MessageBoxOptions && Caption(TranslatableString caption_) &&
Definition: BasicUI.h:98

References BasicUI::MessageBoxOptions::Caption(), PluginManagerInterface::DefaultRegistrationCallback(), FileNames::DoCopyFile(), ModuleManager::Get(), id, ident(), PluginProvider::InstallPath(), mRegisteredPlugins, name, names, PluginsOfType(), PluginTypeModule, Save(), BasicUI::ShowMessageBox(), Verbatim(), wxT(), XO, and XPC.

Here is the call graph for this function:

◆ EffectsOfType()

Range PluginManager::EffectsOfType ( EffectType  type)
inline

Definition at line 148 of file PluginManager.h.

148{ 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 1112 of file PluginManager.cpp.

1113{
1114 if (auto iter = mRegisteredPlugins.find(ID); iter == mRegisteredPlugins.end())
1115 return;
1116 else
1117 iter->second.SetEnabled(enable);
1118}

References mRegisteredPlugins.

◆ FindFilesInPathList()

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

Implements PluginManagerInterface.

Definition at line 203 of file PluginManager.cpp.

207{
208
209 wxLogNull nolog;
210
211 // Why bother...
212 if (pattern.empty())
213 {
214 return;
215 }
216
217 // TODO: We REALLY need to figure out the "Audacity" plug-in path(s)
218
219 FilePaths paths;
220
221 // Add the "per-user" plug-ins directory
222 {
223 const wxFileName &ff = FileNames::PlugInDir();
224 paths.push_back(ff.GetFullPath());
225 }
226
227 // Add the "Audacity" plug-ins directory
229#if defined(__WXMAC__)
230 // Path ends for example in "Audacity.app/Contents/MacOSX"
231 //ff.RemoveLastDir();
232 //ff.RemoveLastDir();
233 // just remove the MacOSX part.
234 ff.RemoveLastDir();
235#endif
236 ff.AppendDir(wxT("plug-ins"));
237 paths.push_back(ff.GetPath());
238
239 // Weed out duplicates
240 for (const auto &filePath : pathList)
241 {
242 ff = filePath;
243 const wxString path{ ff.GetFullPath() };
244 if (paths.Index(path, wxFileName::IsCaseSensitive()) == wxNOT_FOUND)
245 {
246 paths.push_back(path);
247 }
248 }
249
250 // Find all matching files in each path
251 for (size_t i = 0, cnt = paths.size(); i < cnt; i++)
252 {
253 ff = paths[i] + wxFILE_SEP_PATH + pattern;
254 wxDir::GetAllFiles(ff.GetPath(), &files, ff.GetFullName(), directories ? wxDIR_DEFAULT : wxDIR_FILES);
255 }
256
257 return;
258}
static const FilePath & GetExecutablePath()
Extend wxArrayString with move operations and construction and insertion fromstd::initializer_list.
FILES_API FilePath PlugInDir()
The user plug-in directory (not a system one)

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

Here is the call graph for this function:

◆ Get()

PluginManager & PluginManager::Get ( )
static

Definition at line 378 of file PluginManager.cpp.

379{
380 if (!mInstance)
381 {
383 }
384
385 return *mInstance;
386}
#define safenew
Definition: MemoryX.h:10
PluginManager maintains a list of all plug ins. That covers modules, effects, generators,...
Definition: PluginManager.h:42
static std::unique_ptr< PluginManager > mInstance

References mInstance, and safenew.

Referenced by anonymous_namespace{PluginMenus.cpp}::AddEffectMenuItemGroup(), MacroCommands::ApplyEffectCommand(), PluginManagerInterface::AudacityCommandRegistrationCallback(), PluginManagerInterface::DefaultRegistrationCallback(), anonymous_namespace{PluginHost.cpp}::Discover(), MacroCommands::DoAudacityCommand(), EffectUI::DoEffect(), anonymous_namespace{PluginMenus.cpp}::DoManagePluginsMenu(), EffectManager::GetAudacityCommand(), EffectManager::GetCommandIdentifier(), EffectManager::GetCommandSymbol(), PluginSettings::GetConfigSubgroups(), PluginSettings::GetConfigValue(), EffectManager::GetEffectByIdentifier(), EffectManager::GetEffectFamilyName(), anonymous_namespace{EffectsPrefs.cpp}::GetModuleData(), anonymous_namespace{RealtimeEffectPanel.cpp}::RealtimeEffectControl::GetPlugin(), EffectManager::GetVendorName(), HandleTextualCommand(), PluginSettings::HasConfigGroup(), PluginSettings::HasConfigValue(), AudacityApp::InitPart2(), anonymous_namespace{PluginMenus.cpp}::IsEnabledPlugin(), anonymous_namespace{EffectManager.cpp}::LoadComponent(), MacroCommandsCatalog::MacroCommandsCatalog(), AudacityApp::OnExit(), PluginRegistrationDialog::OnOK(), PluginStartupRegistration::OnPluginFound(), PluginRegistrationDialog::OnRescan(), PluginStartupRegistration::OnValidationFinished(), ProjectFileManager::OpenFile(), anonymous_namespace{PluginMenus.cpp}::PopulateEffectsMenu(), PluginRegistrationDialog::PopulateOrExchange(), EffectManager::RegisterEffect(), PluginSettings::RemoveConfig(), PluginSettings::RemoveConfigSubgroup(), GetInfoCommand::SendCommands(), PluginSettings::SetConfigValue(), anonymous_namespace{RealtimeEffectPanel.cpp}::ShowSelectEffectMenu(), PluginStartupRegistration::Stop(), EffectManager::SupportsAutomation(), anonymous_namespace{TrackMenus.cpp}::TracksMenu(), and EffectManager::UnregisterEffect().

Here is the caller graph for this function:

◆ GetConfigSubgroups()

bool PluginManager::GetConfigSubgroups ( ConfigurationType  type,
const PluginID ID,
const RegistryPath group,
RegistryPaths subgroups 
)
overridevirtual

Implements PluginManagerInterface.

Definition at line 266 of file PluginManager.cpp.

268{
269 return GetSubgroups(Group(type, ID, group), subgroups);
270}
RegistryPath Group(ConfigurationType type, const PluginID &ID, const RegistryPath &group)
bool GetSubgroups(const RegistryPath &group, RegistryPaths &subgroups)

References GetSubgroups(), and Group().

Here is the call graph for this function:

◆ GetConfigValue() [1/2]

bool PluginManager::GetConfigValue ( ConfigurationType  type,
const PluginID ID,
const RegistryPath group,
const RegistryPath key,
ConfigReference  var,
ConfigConstReference  defval 
)
overridevirtual
Precondition
var and defval wrap references to the same type (ignoring const)

Implements PluginManagerInterface.

Definition at line 278 of file PluginManager.cpp.

281{
282 return GetConfigValue(Key(type, ID, group, key), var, defval);
283}
static const AudacityProject::AttachedObjects::RegisteredFactory key
bool GetConfigValue(ConfigurationType type, const PluginID &ID, const RegistryPath &group, const RegistryPath &key, ConfigReference var, ConfigConstReference defval) override
RegistryPath Key(ConfigurationType type, const PluginID &ID, const RegistryPath &group, const RegistryPath &key)

References GetConfigValue(), Key(), and key.

Referenced by GetConfigValue().

Here is the call graph for this function:
Here is the caller graph for this function:

◆ GetConfigValue() [2/2]

bool PluginManager::GetConfigValue ( const RegistryPath key,
ConfigReference  var,
ConfigConstReference  defval 
)
private

Definition at line 1404 of file PluginManager.cpp.

1406{
1407 if (key.empty())
1408 return false;
1409 const auto visitor = [&](const auto var){
1410 const auto pVar = &var.get();
1411 // precondition is that defval wraps same type as var
1412 using Type = typename decltype(var)::type;
1413 const auto pDefval =
1414 std::get_if<std::reference_wrapper<const Type>>(&defval);
1415 return GetSettings()->Read(key, pVar, *pDefval);
1416 };
1417 return Visit(visitor, var);
1418}
auto Visit(Visitor &&vis, Variant &&var)
Mimic some of std::visit, for the case of one visitor only.
Definition: MemoryX.h:611
FileConfig * GetSettings()

References GetSettings(), key, and Visit().

Here is the call graph for this function:

◆ GetEffectNameFromID()

Identifier PluginManager::GetEffectNameFromID ( const PluginID ID)
static

Parse English effect name from the result of GetID(const EffectDefinitionInterface*)

Definition at line 1266 of file PluginManager.cpp.

1267{
1268 auto strings = wxSplit(ID, '_');
1269 if (strings.size() == 5)
1270 return strings[3];
1271 return {};
1272}

Referenced by anonymous_namespace{RealtimeEffectPanel.cpp}::RealtimeEffectControl::GetEffectName().

Here is the caller graph for this function:

◆ GetID() [1/3]

PluginID PluginManager::GetID ( ComponentInterface command)
static

Definition at line 1235 of file PluginManager.cpp.

1236{
1237 return wxString::Format(wxT("%s_%s_%s_%s_%s"),
1239 wxEmptyString,
1240 command->GetVendor().Internal(),
1241 command->GetSymbol().Internal(),
1242 command->GetPath());
1243}
@ PluginTypeAudacityCommand
virtual PluginPath GetPath() const =0
virtual VendorSymbol GetVendor() const =0
virtual ComponentInterfaceSymbol GetSymbol() const =0
const wxString & Internal() const
static wxString GetPluginTypeString(PluginType type)

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

Here is the call graph for this function:

◆ GetID() [2/3]

PluginID PluginManager::GetID ( const EffectDefinitionInterface effect)
static

Definition at line 1255 of file PluginManager.cpp.

1256{
1257 return wxJoin(wxArrayStringEx{
1259 effect->GetFamily().Internal(),
1260 effect->GetVendor().Internal(),
1261 effect->GetSymbol().Internal(),
1262 effect->GetPath()
1263 }, '_');
1264}
virtual EffectFamilySymbol GetFamily() const =0
Report identifier and user-visible name of the effect protocol.

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 ( PluginProvider provider)
static

Definition at line 1230 of file PluginManager.cpp.

1231{
1232 return ModuleManager::GetID(provider);
1233}
static PluginID GetID(PluginProvider *provider)

References ModuleManager::GetID().

Referenced by GetID(), RegisterPlugin(), and RealtimeEffectState::WriteXML().

Here is the call graph for this function:
Here is the caller graph for this function:

◆ GetPlugin()

const PluginDescriptor * PluginManager::GetPlugin ( const PluginID ID) const

Definition at line 1036 of file PluginManager.cpp.

1037{
1038 if (auto iter = mRegisteredPlugins.find(ID); iter != mRegisteredPlugins.end())
1039 return &iter->second;
1040
1042 .find_if([&ID](const PluginDescriptor& plug) {
1043 return plug.GetID() == ID;
1044 });
1045 if (iter2 != mEffectPluginsCleared.end())
1046 return &(*iter2);
1047
1048 return nullptr;
1049}
const wxString & GetID() const

References PluginDescriptor::GetID(), make_iterator_range(), mEffectPluginsCleared, and mRegisteredPlugins.

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

Here is the call graph for this function:
Here is the caller graph for this function:

◆ GetPluginCount()

int PluginManager::GetPluginCount ( PluginType  type)

Definition at line 1030 of file PluginManager.cpp.

1031{
1032 return count_if(mRegisteredPlugins.begin(), mRegisteredPlugins.end(), [type](auto &pair){
1033 return pair.second.GetPluginType() == type; });
1034}

References mRegisteredPlugins.

◆ GetPluginEnabledSetting() [1/2]

RegistryPath PluginManager::GetPluginEnabledSetting ( const PluginDescriptor desc) const

Definition at line 111 of file PluginManager.cpp.

113{
114 switch ( desc.GetPluginType() ) {
115 case PluginTypeModule: {
116 // Retrieve optional family symbol that was recorded in
117 // RegisterPlugin() for the module
118 auto family = desc.GetEffectFamily();
119 if ( family.empty() ) // as for built-in effect and command modules
120 return {};
121 else
122 return wxT('/') + family + wxT("/Enable");
123 }
124 case PluginTypeEffect:
125 // do NOT use GetEffectFamily() for this descriptor, but instead,
126 // delegate to the plugin descriptor of the provider, which may
127 // be different (may be empty)
128 return GetPluginEnabledSetting( desc.GetProviderID() );
129 default:
130 return {};
131 }
132}
RegistryPath GetPluginEnabledSetting(const PluginID &ID) const

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

Here is the call graph for this function:

◆ GetPluginEnabledSetting() [2/2]

RegistryPath PluginManager::GetPluginEnabledSetting ( const PluginID ID) const

Definition at line 103 of file PluginManager.cpp.

104{
105 auto pPlugin = GetPlugin( ID );
106 if ( pPlugin )
107 return GetPluginEnabledSetting( *pPlugin );
108 return {};
109}
const PluginDescriptor * GetPlugin(const PluginID &ID) const

References GetPlugin(), and GetPluginEnabledSetting().

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 1276 of file PluginManager.cpp.

1277{
1278 wxString str;
1279
1280 switch (type)
1281 {
1282 default:
1283 case PluginTypeNone:
1284 str = wxT("Placeholder");
1285 break;
1286 case PluginTypeStub:
1287 str = wxT("Stub");
1288 break;
1289 case PluginTypeEffect:
1290 str = wxT("Effect");
1291 break;
1293 str = wxT("Generic");
1294 break;
1295 case PluginTypeExporter:
1296 str = wxT("Exporter");
1297 break;
1298 case PluginTypeImporter:
1299 str = wxT("Importer");
1300 break;
1301 case PluginTypeModule:
1303 break;
1304 }
1305
1306 return str;
1307}
#define str(a)
@ PluginTypeExporter
@ PluginTypeImporter
static wxString GetPluginTypeString()

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

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

Here is the call graph for this function:
Here is the caller graph for this function:

◆ GetRegistryVersion()

const PluginRegistryVersion & PluginManager::GetRegistryVersion ( ) const
overridevirtual

What is the plugin registry version number now in the file? (Save() updates it)

Implements PluginManagerInterface.

Definition at line 912 of file PluginManager.cpp.

913{
914 return mRegver;
915}
PluginRegistryVersion mRegver

References mRegver.

◆ GetSettings()

FileConfig * PluginManager::GetSettings ( )
private

Definition at line 1327 of file PluginManager.cpp.

1328{
1329 if (!mSettings)
1330 {
1332
1333 // Check for a settings version that we can understand
1334 if (mSettings->HasEntry(SETVERKEY))
1335 {
1336 wxString setver = mSettings->Read(SETVERKEY, SETVERKEY);
1337 if (setver < SETVERCUR )
1338 {
1339 // This is where we'd put in conversion code when the
1340 // settings version changes.
1341 //
1342 // Should also check for a settings file that is newer than
1343 // what we can understand.
1344 }
1345 }
1346 else
1347 {
1348 // Make sure is has a version string
1349 mSettings->Write(SETVERKEY, SETVERCUR);
1350 mSettings->Flush();
1351 }
1352 }
1353
1354 return mSettings.get();
1355}
#define SETVERKEY
#define SETVERCUR
static PluginManager::FileConfigFactory sFactory
FILES_API FilePath PluginSettings()

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

Referenced by GetConfigValue(), GetSubgroups(), HasConfigValue(), HasGroup(), Initialize(), RemoveConfig(), RemoveConfigSubgroup(), and SetConfigValue().

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 1374 of file PluginManager.cpp.

1375{
1376 if (group.empty() || !HasGroup(group))
1377 {
1378 return false;
1379 }
1380
1381 wxString path = GetSettings()->GetPath();
1382 GetSettings()->SetPath(group);
1383
1384 wxString name;
1385 long index = 0;
1386 if (GetSettings()->GetFirstGroup(name, index))
1387 {
1388 do
1389 {
1390 subgroups.push_back(name);
1391 } while (GetSettings()->GetNextGroup(name, index));
1392 }
1393
1394 GetSettings()->SetPath(path);
1395
1396 return true;
1397}
virtual const wxString & GetPath() const wxOVERRIDE
Definition: FileConfig.cpp:98
virtual void SetPath(const wxString &strPath) wxOVERRIDE
Definition: FileConfig.cpp:93
bool HasGroup(const RegistryPath &group)

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

Referenced by GetConfigSubgroups().

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 1120 of file PluginManager.cpp.

1121{
1122 if (auto iter = mRegisteredPlugins.find(ID); iter == mRegisteredPlugins.end()) {
1123 static ComponentInterfaceSymbol empty;
1124 return empty;
1125 }
1126 else
1127 return iter->second.GetSymbol();
1128}
ComponentInterfaceSymbol pairs a persistent string identifier used internally with an optional,...

References mRegisteredPlugins.

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

Here is the caller graph for this function:

◆ Group()

RegistryPath PluginManager::Group ( ConfigurationType  type,
const PluginID ID,
const RegistryPath group 
)
private

Definition at line 1464 of file PluginManager.cpp.

1466{
1467 auto path = SettingsPath(type, ID);
1468
1469 wxFileName ff(group);
1470 if (!ff.GetName().empty())
1471 {
1472 path += ff.GetFullPath(wxPATH_UNIX) + wxCONFIG_PATH_SEPARATOR;
1473 }
1474
1475 return path;
1476}
RegistryPath SettingsPath(ConfigurationType type, const PluginID &ID)

References SettingsPath().

Referenced by GetConfigSubgroups(), HasConfigGroup(), Key(), and RemoveConfigSubgroup().

Here is the call graph for this function:
Here is the caller graph for this function:

◆ HasConfigGroup()

bool PluginManager::HasConfigGroup ( ConfigurationType  type,
const PluginID ID,
const RegistryPath group 
)

Definition at line 260 of file PluginManager.cpp.

262{
263 return HasGroup(Group(type, ID, group));
264}

References Group(), and HasGroup().

Here is the call graph for this function:

◆ HasConfigValue() [1/2]

bool PluginManager::HasConfigValue ( ConfigurationType  type,
const PluginID ID,
const RegistryPath group,
const RegistryPath key 
)
overridevirtual

Implements PluginManagerInterface.

Definition at line 272 of file PluginManager.cpp.

274{
275 return HasConfigValue(Key(type, ID, group, key));
276}
bool HasConfigValue(ConfigurationType type, const PluginID &ID, const RegistryPath &group, const RegistryPath &key) override

References HasConfigValue(), Key(), and key.

Referenced by HasConfigValue().

Here is the call graph for this function:
Here is the caller graph for this function:

◆ HasConfigValue() [2/2]

bool PluginManager::HasConfigValue ( const RegistryPath key)
private

Definition at line 1399 of file PluginManager.cpp.

1400{
1401 return GetSettings()->Exists(key);
1402}

References GetSettings(), and key.

Here is the call graph for this function:

◆ HasGroup()

bool PluginManager::HasGroup ( const RegistryPath group)
private

Definition at line 1357 of file PluginManager.cpp.

1358{
1359 auto settings = GetSettings();
1360
1361 bool res = settings->HasGroup(group);
1362 if (res)
1363 {
1364 // The group exists, but empty groups aren't considered valid
1365 wxString oldPath = settings->GetPath();
1366 settings->SetPath(group);
1367 res = settings->GetNumberOfEntries() || settings->GetNumberOfGroups();
1368 settings->SetPath(oldPath);
1369 }
1370
1371 return res;
1372}
static Settings & settings()
Definition: TrackInfo.cpp:87

References GetSettings(), and settings().

Referenced by GetSubgroups(), and HasConfigGroup().

Here is the call graph for this function:
Here is the caller graph for this function:

◆ Initialize()

void PluginManager::Initialize ( FileConfigFactory  factory)
Precondition
factory != nullptr

Definition at line 388 of file PluginManager.cpp.

389{
390 sFactory = move(factory);
391
392 // Always load the registry first
393 Load();
394
395 // And force load of setting to verify it's accessible
396 GetSettings();
397
398 auto &mm = ModuleManager::Get();
399 mm.DiscoverProviders();
400 for (auto& [id, module] : mm.Providers()) {
401 RegisterPlugin(module.get());
402 // Allow the module to auto-register children
403 module->AutoRegisterPlugins(*this);
404 }
405
407}
void Load()
Load from preferences.
void RegisterPlugin(PluginDescriptor &&desc)
void InitializePlugins()
static RegisteredToolbarFactory factory

References cloud::factory, ModuleManager::Get(), GetSettings(), InitializePlugins(), Load(), RegisterPlugin(), and sFactory.

Referenced by AudacityApp::InitPart2().

Here is the call graph for this function:
Here is the caller graph for this function:

◆ InitializePlugins()

void PluginManager::InitializePlugins ( )
private

Definition at line 340 of file PluginManager.cpp.

341{
342 ModuleManager & moduleManager = ModuleManager::Get();
343 //ModuleManager::DiscoverProviders was called earlier, so we
344 //can be sure that providers are already loaded
345
346 //Check all known plugins to ensure they are still valid.
347 for (auto it = mRegisteredPlugins.begin(); it != mRegisteredPlugins.end();) {
348 auto &pluginDesc = it->second;
349 const auto pluginType = pluginDesc.GetPluginType();
350 if(pluginType == PluginTypeNone || pluginType == PluginTypeModule)
351 {
352 ++it;
353 continue;
354 }
355
356 if(!moduleManager.CheckPluginExist(pluginDesc.GetProviderID(), pluginDesc.GetPath()))
357 it = mRegisteredPlugins.erase(it);
358 else
359 ++it;
360 }
361
362 Save();
363}
bool CheckPluginExist(const PluginID &providerId, const PluginPath &path)

References ModuleManager::CheckPluginExist(), ModuleManager::Get(), mRegisteredPlugins, PluginTypeModule, PluginTypeNone, and Save().

Referenced by Initialize().

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 1104 of file PluginManager.cpp.

1105{
1106 if (auto iter = mRegisteredPlugins.find(ID); iter == mRegisteredPlugins.end())
1107 return false;
1108 else
1109 return iter->second.IsEnabled();
1110}

References mRegisteredPlugins.

◆ IsPluginLoaded()

bool PluginManager::IsPluginLoaded ( const wxString &  ID) const

Definition at line 148 of file PluginManager.cpp.

149{
150 return mLoadedInterfaces.find(ID) != mLoadedInterfaces.end();
151}
std::map< PluginID, std::unique_ptr< ComponentInterface > > mLoadedInterfaces

References mLoadedInterfaces.

◆ 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
pathan identifier for the plug-in with meaning defined by provider; not always a file path
pNameif 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 134 of file PluginManager.cpp.

136{
137 for (auto &pair : mRegisteredPlugins) {
138 if (auto &descriptor = pair.second; descriptor.GetPath() == path) {
139 if (pName)
140 descriptor.SetSymbol(
141 { descriptor.GetSymbol().Internal(), *pName });
142 return true;
143 }
144 }
145 return false;
146}
@ Internal
Indicates internal failure from Audacity.

References Internal, and mRegisteredPlugins.

◆ Key()

RegistryPath PluginManager::Key ( ConfigurationType  type,
const PluginID ID,
const RegistryPath group,
const RegistryPath key 
)
private

Definition at line 1479 of file PluginManager.cpp.

1481{
1482 auto path = Group(type, ID, group);
1483 if (path.empty())
1484 {
1485 return path;
1486 }
1487
1488 return path + key;
1489}

References Group(), and key.

Referenced by GetConfigValue(), HasConfigValue(), RemoveConfig(), and SetConfigValue().

Here is the call graph for this function:
Here is the caller graph for this function:

◆ Load() [1/2]

void PluginManager::Load ( )

Load from preferences.

Definition at line 538 of file PluginManager.cpp.

539{
540 // Create/Open the registry
541 auto pRegistry = sFactory(FileNames::PluginRegistry());
542 auto &registry = *pRegistry;
543
544 // If this group doesn't exist then we have something that's not a registry.
545 // We should probably warn the user, but it's pretty unlikely that this will happen.
546 if (!registry.HasGroup(REGROOT))
547 {
548 // Must start over
549 // This DeleteAll affects pluginregistry.cfg only, not audacity.cfg
550 // That is, the memory of on/off states of effect (and generator,
551 // analyzer, and tool) plug-ins
552 registry.DeleteAll();
553 registry.Flush();
554 return;
555 }
556
557 // Check for a registry version that we can understand
558 // TODO: Should also check for a registry file that is newer than
559 // what we can understand.
560 mRegver = registry.Read(REGVERKEY);
561 if (Regver_lt(mRegver, "1.1")) {
562 // Conversion code here, for when registry version changes.
563
564 // We iterate through the effects, possibly updating their info.
565 wxString groupName;
566 long groupIndex;
567 wxString group = GetPluginTypeString(PluginTypeEffect);
568 wxString cfgPath = REGROOT + group + wxCONFIG_PATH_SEPARATOR;
569 wxArrayString groupsToDelete;
570
571 registry.SetPath(cfgPath);
572 for (bool cont = registry.GetFirstGroup(groupName, groupIndex);
573 cont;
574 registry.SetPath(cfgPath),
575 cont = registry.GetNextGroup(groupName, groupIndex))
576 {
577 registry.SetPath(groupName);
578 wxString effectSymbol = registry.Read(KEY_SYMBOL, "");
579 wxString effectVersion = registry.Read(KEY_VERSION, "");
580
581
582 // For 2.3.0 the plugins we distribute have moved around.
583 // So we upped the registry version number to 1.1.
584 // These particular config edits were originally written to fix Bug 1914.
585 if (Regver_le(mRegver, "1.0")) {
586 // Nyquist prompt is a built-in that has moved to the tools menu.
587 if (effectSymbol == NYQUIST_PROMPT_ID) {
588 registry.Write(KEY_EFFECTTYPE, "Tool");
589 // Old version of SDE was in Analyze menu. Now it is in Tools.
590 // We don't want both the old and the new.
591 } else if ((effectSymbol == "Sample Data Export") && (effectVersion == "n/a")) {
592 groupsToDelete.push_back(cfgPath + groupName);
593 // Old version of SDI was in Generate menu. Now it is in Tools.
594 } else if ((effectSymbol == "Sample Data Import") && (effectVersion == "n/a")) {
595 groupsToDelete.push_back(cfgPath + groupName);
596 }
597 }
598
599 }
600 // Doing the deletion within the search loop risked skipping some items,
601 // hence the delayed delete.
602 for (unsigned int i = 0; i < groupsToDelete.size(); i++) {
603 registry.DeleteGroup(groupsToDelete[i]);
604 }
605 registry.SetPath("");
606 // Updates done. Make sure we read the updated data later.
607 registry.Flush();
608 }
609
610 // Load all provider plugins first
611 LoadGroup(&registry, PluginTypeModule);
612
613 // Now the rest
614 LoadGroup(&registry, PluginTypeEffect);
616 LoadGroup(&registry, PluginTypeExporter);
617 LoadGroup(&registry, PluginTypeImporter);
618
619 LoadGroup(&registry, PluginTypeStub);
620 return;
621}
bool Regver_lt(const PluginRegistryVersion &regver1, const PluginRegistryVersion &regver2)
bool Regver_le(const PluginRegistryVersion &regver1, const PluginRegistryVersion &regver2)
#define REGVERKEY
#define KEY_SYMBOL
#define REGROOT
#define KEY_VERSION
#define KEY_EFFECTTYPE
#define NYQUIST_PROMPT_ID
void LoadGroup(FileConfig *pRegistry, PluginType type)
FILES_API FilePath PluginRegistry()

References GetPluginTypeString(), KEY_EFFECTTYPE, KEY_SYMBOL, KEY_VERSION, LoadGroup(), mRegver, NYQUIST_PROMPT_ID, FileNames::PluginRegistry(), PluginTypeAudacityCommand, PluginTypeEffect, PluginTypeExporter, PluginTypeImporter, PluginTypeModule, PluginTypeStub, REGROOT, Regver_le(), Regver_lt(), REGVERKEY, and sFactory.

Referenced by Initialize().

Here is the call graph for this function:
Here is the caller graph for this function:

◆ Load() [2/2]

ComponentInterface * PluginManager::Load ( const PluginID ID)

Definition at line 1130 of file PluginManager.cpp.

1131{
1132 if(auto it = mLoadedInterfaces.find(ID); it != mLoadedInterfaces.end())
1133 return it->second.get();
1134
1135 if(auto it = mRegisteredPlugins.find(ID); it != mRegisteredPlugins.end())
1136 {
1137 auto& desc = it->second;
1138 if(desc.GetPluginType() == PluginTypeModule)
1139 //it's very likely that this code path is not used
1140 return ModuleManager::Get().CreateProviderInstance(desc.GetID(), desc.GetPath());
1141
1142 if(auto provider = ModuleManager::Get().CreateProviderInstance(desc.GetProviderID(), wxEmptyString))
1143 {
1144 auto pluginInterface = provider->LoadPlugin(desc.GetPath());
1145 auto result = pluginInterface.get();
1146 mLoadedInterfaces[desc.GetID()] = std::move(pluginInterface);
1147 return result;
1148 }
1149 }
1150 return nullptr;
1151}
PluginProvider * CreateProviderInstance(const PluginID &provider, const PluginPath &path)
virtual std::unique_ptr< ComponentInterface > LoadPlugin(const PluginPath &path)=0
Load the plug-in at a path reported by DiscoverPluginsAtPath.

References ModuleManager::CreateProviderInstance(), desc, ModuleManager::Get(), PluginProvider::LoadPlugin(), mLoadedInterfaces, mRegisteredPlugins, and PluginTypeModule.

Referenced by EffectManager::GetAudacityCommand().

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 623 of file PluginManager.cpp.

624{
625#ifdef __WXMAC__
626 // Bug 1590: On Mac, we should purge the registry of Nyquist plug-ins
627 // bundled with other versions of Audacity, assuming both versions
628 // were properly installed in /Applications (or whatever it is called in
629 // your locale)
630
631 const auto fullExePath = PlatformCompatibility::GetExecutablePath();
632
633 // Strip rightmost path components up to *.app
634 wxFileName exeFn{ fullExePath };
635 exeFn.SetEmptyExt();
636 exeFn.SetName(wxString{});
637 while(exeFn.GetDirCount() && !exeFn.GetDirs().back().EndsWith(".app"))
638 exeFn.RemoveLastDir();
639
640 const auto goodPath = exeFn.GetPath();
641
642 if(exeFn.GetDirCount())
643 exeFn.RemoveLastDir();
644 const auto possiblyBadPath = exeFn.GetPath();
645
646 auto AcceptPath = [&](const wxString &path) {
647 if (!path.StartsWith(possiblyBadPath))
648 // Assume it's not under /Applications
649 return true;
650 if (path.StartsWith(goodPath))
651 // It's bundled with this executable
652 return true;
653 return false;
654 };
655#else
656 auto AcceptPath = [](const wxString&){ return true; };
657#endif
658
659 wxString strVal;
660 bool boolVal;
661 wxString groupName;
662 long groupIndex;
663 wxString group = GetPluginTypeString(type);
664 wxString cfgPath = REGROOT + group + wxCONFIG_PATH_SEPARATOR;
665
666 pRegistry->SetPath(cfgPath);
667 for (bool cont = pRegistry->GetFirstGroup(groupName, groupIndex);
668 cont;
669 pRegistry->SetPath(cfgPath),
670 cont = pRegistry->GetNextGroup(groupName, groupIndex))
671 {
672 PluginDescriptor plug;
673
674 pRegistry->SetPath(groupName);
675
676 groupName = ConvertID(groupName);
677
678 // Bypass group if the ID is already in use
679 if (mRegisteredPlugins.count(groupName))
680 continue;
681
682 // Set the ID and type
683 plug.SetID(groupName);
684 plug.SetPluginType(type);
685
686 // Get the provider ID and bypass group if not found
687 if (!pRegistry->Read(KEY_PROVIDERID, &strVal, wxEmptyString))
688 {
689 // Bypass group if the provider isn't valid
690 if (!strVal.empty() && !mRegisteredPlugins.count(strVal))
691 continue;
692 }
693 plug.SetProviderID(PluginID(strVal));
694
695 // Get the path (optional)
696 pRegistry->Read(KEY_PATH, &strVal, wxEmptyString);
697 if (!AcceptPath(strVal))
698 // Ignore the obsolete path in the config file, during session,
699 // but don't remove it from the file. Maybe you really want to
700 // switch back to the other version of Audacity and lose nothing.
701 continue;
702 plug.SetPath(strVal);
703
704 /*
705 // PRL: Ignore names written in configs before 2.3.0!
706 // use Internal string only! Let the present version of Audacity map
707 // that to a user-visible string.
708 // Get the name and bypass group if not found
709 if (!pRegistry->Read(KEY_NAME, &strVal))
710 {
711 continue;
712 }
713 plug.SetName(strVal);
714 */
715
716 // Get the symbol...Audacity 2.3.0 or later requires it
717 // bypass group if not found
718 // Note, KEY_SYMBOL started getting written to config files in 2.1.0.
719 // KEY_NAME (now ignored) was written before that, but only for VST
720 // effects.
721 if (!pRegistry->Read(KEY_SYMBOL, &strVal))
722 continue;
723
724 // Related to Bug2778: config file only remembered an internal name,
725 // so this symbol may not contain the correct TranslatableString.
726 // See calls to IsPluginRegistered which can correct that.
727 plug.SetSymbol(strVal);
728
729 // Get the version and bypass group if not found
730 if (!pRegistry->Read(KEY_VERSION, &strVal))
731 {
732 continue;
733 }
734 plug.SetVersion(strVal);
735
736 // Get the vendor and bypass group if not found
737 if (!pRegistry->Read(KEY_VENDOR, &strVal))
738 {
739 continue;
740 }
741 plug.SetVendor( strVal );
742
743#if 0
744 // This was done before version 2.2.2, but the value was not really used
745 // But absence of a value will cause early versions to skip the group
746 // Therefore we still write a blank to keep pluginregistry.cfg
747 // backwards-compatible
748
749 // Get the description and bypass group if not found
750 if (!pRegistry->Read(KEY_DESCRIPTION, &strVal))
751 {
752 continue;
753 }
754#endif
755
756 // Is it enabled...default to no if not found
757 pRegistry->Read(KEY_ENABLED, &boolVal, false);
758 plug.SetEnabled(boolVal);
759
760 // Is it valid...default to no if not found
761 pRegistry->Read(KEY_VALID, &boolVal, false);
762 plug.SetValid(boolVal);
763
764 switch (type)
765 {
766 case PluginTypeModule:
767 {
768 // Nothing to do here yet
769 }
770 break;
771
772 case PluginTypeEffect:
773 {
774 // Get the effect type and bypass group if not found
775 if (!pRegistry->Read(KEY_EFFECTTYPE, &strVal))
776 continue;
777
778 if (strVal == KEY_EFFECTTYPE_NONE)
780 else if (strVal == KEY_EFFECTTYPE_ANALYZE)
782 else if (strVal == KEY_EFFECTTYPE_GENERATE)
784 else if (strVal == KEY_EFFECTTYPE_PROCESS)
786 else if (strVal == KEY_EFFECTTYPE_TOOL)
788 else if (strVal == KEY_EFFECTTYPE_HIDDEN)
790 else
791 continue;
792
793 // Get the effect family and bypass group if not found
794 if (!pRegistry->Read(KEY_EFFECTFAMILY, &strVal))
795 {
796 continue;
797 }
798 plug.SetEffectFamily(strVal);
799
800 // Is it a default (above the line) effect and bypass group if not found
801 if (!pRegistry->Read(KEY_EFFECTDEFAULT, &boolVal))
802 {
803 continue;
804 }
805 plug.SetEffectDefault(boolVal);
806
807 // Is it an interactive effect and bypass group if not found
808 if (!pRegistry->Read(KEY_EFFECTINTERACTIVE, &boolVal))
809 {
810 continue;
811 }
812 plug.SetEffectInteractive(boolVal);
813
814 // Is it a realtime capable effect and bypass group if not found
815 if (!pRegistry->Read(KEY_EFFECTREALTIME, &strVal))
816 {
817 continue;
818 }
819 plug.DeserializeRealtimeSupport(strVal);
820
821 // Does the effect support automation...bypass group if not found
822 if (!pRegistry->Read(KEY_EFFECTAUTOMATABLE, &boolVal))
823 {
824 continue;
825 }
826 plug.SetEffectAutomatable(boolVal);
827 }
828 break;
829
831 {
832 // Get the importer identifier and bypass group if not found
833 if (!pRegistry->Read(KEY_IMPORTERIDENT, &strVal))
834 {
835 continue;
836 }
837 plug.SetImporterIdentifier(strVal);
838
839 // Get the importer extensions and bypass group if not found
840 if (!pRegistry->Read(KEY_IMPORTEREXTENSIONS, &strVal))
841 {
842 continue;
843 }
844 FileExtensions extensions;
845 wxStringTokenizer tkr(strVal, wxT(":"));
846 while (tkr.HasMoreTokens())
847 {
848 extensions.push_back(tkr.GetNextToken());
849 }
850 plug.SetImporterExtensions(extensions);
851 }
852 break;
853
854 case PluginTypeStub:
855 {
856 // Nothing additional for stubs
857 }
858 break;
859
860 // Not used by 2.1.1 or greater and should be removed after a few releases past 2.1.0.
861 case PluginTypeNone:
862 {
863 // Used for stub groups
864 }
865 break;
866
867 default:
868 {
869 continue;
870 }
871 }
872
873 // Everything checked out...accept the plugin
874 mRegisteredPlugins[groupName] = std::move(plug);
875 }
876
877 return;
878}
@ EffectTypeHidden
@ EffectTypeAnalyze
@ EffectTypeGenerate
@ EffectTypeNone
@ EffectTypeTool
@ EffectTypeProcess
#define KEY_EFFECTAUTOMATABLE
#define KEY_PROVIDERID
#define KEY_IMPORTEREXTENSIONS
#define KEY_EFFECTTYPE_TOOL
#define KEY_VENDOR
#define KEY_PATH
#define KEY_IMPORTERIDENT
#define KEY_EFFECTTYPE_GENERATE
#define KEY_EFFECTTYPE_PROCESS
#define KEY_EFFECTINTERACTIVE
#define KEY_EFFECTTYPE_HIDDEN
#define KEY_ENABLED
#define KEY_EFFECTREALTIME
#define KEY_EFFECTTYPE_NONE
#define KEY_EFFECTFAMILY
#define KEY_VALID
#define KEY_EFFECTTYPE_ANALYZE
#define KEY_DESCRIPTION
#define KEY_EFFECTDEFAULT
virtual bool GetNextGroup(wxString &str, long &lIndex) const wxOVERRIDE
Definition: FileConfig.cpp:108
virtual bool GetFirstGroup(wxString &str, long &lIndex) const wxOVERRIDE
Definition: FileConfig.cpp:103
void SetEnabled(bool enable)
void SetImporterExtensions(FileExtensions extensions)
void SetImporterIdentifier(const wxString &identifier)
void SetValid(bool valid)
void SetProviderID(const PluginID &providerID)
void SetEffectType(EffectType type)
void SetEffectFamily(const wxString &family)
void SetEffectAutomatable(bool automatable)
void SetEffectDefault(bool dflt)
void SetEffectInteractive(bool interactive)
void DeserializeRealtimeSupport(const wxString &value)
for deserialization
wxString ConvertID(const PluginID &ID)

References ConvertID(), PluginDescriptor::DeserializeRealtimeSupport(), 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, mRegisteredPlugins, PluginTypeEffect, PluginTypeImporter, PluginTypeModule, PluginTypeNone, PluginTypeStub, REGROOT, PluginDescriptor::SetEffectAutomatable(), PluginDescriptor::SetEffectDefault(), PluginDescriptor::SetEffectFamily(), PluginDescriptor::SetEffectInteractive(), PluginDescriptor::SetEffectType(), PluginDescriptor::SetEnabled(), PluginDescriptor::SetID(), PluginDescriptor::SetImporterExtensions(), PluginDescriptor::SetImporterIdentifier(), PluginDescriptor::SetPath(), FileConfig::SetPath(), PluginDescriptor::SetPluginType(), PluginDescriptor::SetProviderID(), PluginDescriptor::SetSymbol(), PluginDescriptor::SetValid(), PluginDescriptor::SetVendor(), PluginDescriptor::SetVersion(), and wxT().

Referenced by Load().

Here is the call graph for this function:
Here is the caller graph for this function:

◆ OldGetID()

PluginID PluginManager::OldGetID ( const EffectDefinitionInterface effect)
static

Definition at line 1245 of file PluginManager.cpp.

1246{
1247 return wxString::Format(wxT("%s_%s_%s_%s_%s"),
1249 effect->GetFamily().Internal(),
1250 effect->GetVendor().Internal(),
1251 effect->GetSymbol().Internal(),
1252 effect->GetPath());
1253}

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

Here is the call graph for this function:

◆ PluginsOfType()

Range PluginManager::PluginsOfType ( int  type)
inline

Definition at line 147 of file PluginManager.h.

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

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

Here is the caller graph for this function:

◆ RegisterPlugin() [1/5]

void PluginManager::RegisterPlugin ( PluginDescriptor &&  desc)

Definition at line 153 of file PluginManager.cpp.

154{
155 mRegisteredPlugins[desc.GetID()] = std::move(desc);
156}

References desc, and mRegisteredPlugins.

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

Here is the caller graph for this function:

◆ RegisterPlugin() [2/5]

const PluginID & PluginManager::RegisterPlugin ( PluginProvider provider)
overridevirtual

Implements PluginManagerInterface.

Definition at line 158 of file PluginManager.cpp.

159{
160 PluginDescriptor & plug =
161 CreatePlugin(GetID(provider), provider, PluginTypeModule);
163
164 plug.SetEnabled(true);
165 plug.SetValid(true);
166
167 return plug.GetID();
168}
static PluginID GetID(PluginProvider *provider)
PluginDescriptor & CreatePlugin(const PluginID &id, ComponentInterface *ident, PluginType type)
virtual EffectFamilySymbol GetOptionalFamilySymbol()=0
A symbol identifying the family of plug-ins provided by this.

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

Here is the call graph for this function:

◆ RegisterPlugin() [3/5]

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

Definition at line 170 of file PluginManager.cpp.

172{
174
175 plug.SetProviderID(PluginManager::GetID(provider));
176
177 plug.SetEnabled(true);
178 plug.SetValid(true);
179
180 return plug.GetID();
181}
PluginType

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

Here is the call graph for this function:

◆ RegisterPlugin() [4/5]

const PluginID & PluginManager::RegisterPlugin ( PluginProvider provider,
EffectDefinitionInterface effect,
int  type 
)
overridevirtual

Implements PluginManagerInterface.

Definition at line 183 of file PluginManager.cpp.

185{
186 PluginDescriptor & plug = CreatePlugin(GetID(effect), effect, (PluginType)type);
187
188 plug.SetProviderID(PluginManager::GetID(provider));
189
190 plug.SetEffectType(effect->GetClassification());
191 plug.SetEffectFamily(effect->GetFamily().Internal());
192 plug.SetEffectInteractive(effect->IsInteractive());
193 plug.SetEffectDefault(effect->IsDefault());
194 plug.SetRealtimeSupport(effect->RealtimeSupport());
196
197 plug.SetEnabled(true);
198 plug.SetValid(true);
199
200 return plug.GetID();
201}
virtual EffectType GetClassification() const
Determines which menu it appears in; default same as GetType().
virtual bool IsDefault() const =0
Whether the effect sorts "above the line" in the menus.
virtual bool IsInteractive() const =0
Whether the effect needs a dialog for entry of settings.
virtual bool SupportsAutomation() const =0
Whether the effect has any automatable controls.
virtual RealtimeSince RealtimeSupport() const =0
Since which version of Audacity has the effect supported realtime?
void SetRealtimeSupport(EffectDefinitionInterface::RealtimeSince realtime)

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

Here is the call graph for this function:

◆ RegisterPlugin() [5/5]

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

Used only by Nyquist Workbench module.

Definition at line 1002 of file PluginManager.cpp.

1004{
1005 PluginDescriptor & plug =
1006 CreatePlugin(GetID(effect.get()), effect.get(), type);
1007
1008 plug.SetEffectType(effect->GetType());
1009 plug.SetEffectFamily(effect->GetFamily().Internal());
1010 plug.SetEffectInteractive(effect->IsInteractive());
1011 plug.SetEffectDefault(effect->IsDefault());
1012 plug.SetRealtimeSupport(effect->RealtimeSupport());
1013 plug.SetEffectAutomatable(effect->SupportsAutomation());
1014
1015 plug.SetEffectLegacy(true);
1016 plug.SetEnabled(true);
1017 plug.SetValid(true);
1018
1019 mLoadedInterfaces[plug.GetID()] = std::move(effect);
1020
1021 return plug.GetID();
1022}
void SetEffectLegacy(bool legacy)

References CreatePlugin(), PluginDescriptor::GetID(), GetID(), mLoadedInterfaces, PluginDescriptor::SetEffectAutomatable(), PluginDescriptor::SetEffectDefault(), PluginDescriptor::SetEffectFamily(), PluginDescriptor::SetEffectInteractive(), PluginDescriptor::SetEffectLegacy(), PluginDescriptor::SetEffectType(), PluginDescriptor::SetEnabled(), PluginDescriptor::SetRealtimeSupport(), and PluginDescriptor::SetValid().

Here is the call graph for this function:

◆ RemoveConfig()

bool PluginManager::RemoveConfig ( ConfigurationType  type,
const PluginID ID,
const RegistryPath group,
const RegistryPath key 
)
overridevirtual

Implements PluginManagerInterface.

Definition at line 304 of file PluginManager.cpp.

306{
307 bool result = GetSettings()->DeleteEntry(Key(type, ID, group, key));
308 if (result)
309 {
310 GetSettings()->Flush();
311 }
312
313 return result;
314}
virtual bool DeleteEntry(const wxString &key, bool bDeleteGroupIfEmpty=true) wxOVERRIDE
Definition: FileConfig.cpp:209
virtual bool Flush(bool bCurrentOnly=false) wxOVERRIDE
Definition: FileConfig.cpp:143

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

Here is the call graph for this function:

◆ RemoveConfigSubgroup()

bool PluginManager::RemoveConfigSubgroup ( ConfigurationType  type,
const PluginID ID,
const RegistryPath group 
)
overridevirtual

Implements PluginManagerInterface.

Definition at line 292 of file PluginManager.cpp.

294{
295 bool result = GetSettings()->DeleteGroup(Group(type, ID, group));
296 if (result)
297 {
298 GetSettings()->Flush();
299 }
300
301 return result;
302}
virtual bool DeleteGroup(const wxString &key) wxOVERRIDE
Definition: FileConfig.cpp:219

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

Here is the call graph for this function:

◆ Save()

void PluginManager::Save ( )

Save to preferences.

Definition at line 880 of file PluginManager.cpp.

881{
882 // Create/Open the registry
883 auto pRegistry = sFactory(FileNames::PluginRegistry());
884 auto &registry = *pRegistry;
885
886 // Clear pluginregistry.cfg (not audacity.cfg)
887 registry.DeleteAll();
888
889 // Save the individual groups
890 SaveGroup(&registry, PluginTypeEffect);
891 SaveGroup(&registry, PluginTypeExporter);
893 SaveGroup(&registry, PluginTypeImporter);
894 SaveGroup(&registry, PluginTypeStub);
895
896 // Not used by 2.1.1 or greater, but must save to allow users to switch between 2.1.0
897 // and 2.1.1+. This should be removed after a few releases past 2.1.0.
898 //SaveGroup(&registry, PluginTypeNone);
899
900 // And now the providers
901 SaveGroup(&registry, PluginTypeModule);
902
903 // Write the version string
904 registry.Write(REGVERKEY, REGVERCUR);
905
906 // Just to be safe
907 registry.Flush();
908
910}
constexpr auto REGVERCUR
void SaveGroup(FileConfig *pRegistry, PluginType type)

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

Referenced by DropFile(), InitializePlugins(), PluginRegistrationDialog::OnOK(), and PluginStartupRegistration::Stop().

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 917 of file PluginManager.cpp.

918{
919 wxString group = GetPluginTypeString(type);
920 for (auto &pair : mRegisteredPlugins) {
921 auto & plug = pair.second;
922
923 if (plug.GetPluginType() != type)
924 {
925 continue;
926 }
927
928 pRegistry->SetPath(REGROOT + group + wxCONFIG_PATH_SEPARATOR + ConvertID(plug.GetID()));
929
930 pRegistry->Write(KEY_PATH, plug.GetPath());
931
932 // See comments with the corresponding load-time call to SetSymbol().
933 pRegistry->Write(KEY_SYMBOL, plug.GetSymbol().Internal());
934
935 // PRL: Writing KEY_NAME which is no longer read, but older Audacity
936 // versions expect to find it.
937 pRegistry->Write(KEY_NAME, plug.GetSymbol().Msgid().MSGID());
938
939 pRegistry->Write(KEY_VERSION, plug.GetUntranslatedVersion());
940 pRegistry->Write(KEY_VENDOR, plug.GetVendor());
941 // Write a blank -- see comments in LoadGroup:
942 pRegistry->Write(KEY_DESCRIPTION, wxString{});
943 pRegistry->Write(KEY_PROVIDERID, plug.GetProviderID());
944 pRegistry->Write(KEY_ENABLED, plug.IsEnabled());
945 pRegistry->Write(KEY_VALID, plug.IsValid());
946
947 switch (type)
948 {
949 case PluginTypeModule:
950 break;
951
952 case PluginTypeEffect:
953 {
954 EffectType etype = plug.GetEffectType();
955 wxString stype;
956 if (etype == EffectTypeNone)
957 stype = KEY_EFFECTTYPE_NONE;
958 else if (etype == EffectTypeAnalyze)
960 else if (etype == EffectTypeGenerate)
962 else if (etype == EffectTypeProcess)
964 else if (etype == EffectTypeTool)
965 stype = KEY_EFFECTTYPE_TOOL;
966 else if (etype == EffectTypeHidden)
967 stype = KEY_EFFECTTYPE_HIDDEN;
968
969 pRegistry->Write(KEY_EFFECTTYPE, stype);
970 pRegistry->Write(KEY_EFFECTFAMILY, plug.GetEffectFamily());
971 pRegistry->Write(KEY_EFFECTDEFAULT, plug.IsEffectDefault());
972 pRegistry->Write(KEY_EFFECTINTERACTIVE, plug.IsEffectInteractive());
973 pRegistry->Write(KEY_EFFECTREALTIME, plug.SerializeRealtimeSupport());
974 pRegistry->Write(KEY_EFFECTAUTOMATABLE, plug.IsEffectAutomatable());
975 }
976 break;
977
979 {
980 pRegistry->Write(KEY_IMPORTERIDENT, plug.GetImporterIdentifier());
981 const auto & extensions = plug.GetImporterExtensions();
982 wxString strExt;
983 for (size_t i = 0, cnt = extensions.size(); i < cnt; i++)
984 {
985 strExt += extensions[i] + wxT(":");
986 }
987 strExt.RemoveLast(1);
988 pRegistry->Write(KEY_IMPORTEREXTENSIONS, strExt);
989 }
990 break;
991
992 default:
993 break;
994 }
995 }
996
997 return;
998}
EffectType
#define KEY_NAME

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, mRegisteredPlugins, PluginTypeEffect, PluginTypeImporter, PluginTypeModule, REGROOT, FileConfig::SetPath(), and wxT().

Referenced by Save().

Here is the call graph for this function:
Here is the caller graph for this function:

◆ SetConfigValue() [1/2]

bool PluginManager::SetConfigValue ( ConfigurationType  type,
const PluginID ID,
const RegistryPath group,
const RegistryPath key,
ConfigConstReference  value 
)
overridevirtual

Implements PluginManagerInterface.

Definition at line 285 of file PluginManager.cpp.

288{
289 return SetConfigValue(Key(type, ID, group, key), value);
290}
bool SetConfigValue(ConfigurationType type, const PluginID &ID, const RegistryPath &group, const RegistryPath &key, ConfigConstReference value) override

References Key(), key, and SetConfigValue().

Referenced by SetConfigValue().

Here is the call graph for this function:
Here is the caller graph for this function:

◆ SetConfigValue() [2/2]

bool PluginManager::SetConfigValue ( const RegistryPath key,
ConfigConstReference  value 
)
private

Definition at line 1420 of file PluginManager.cpp.

1422{
1423 if (key.empty())
1424 return false;
1425 const auto visitor = [&](const auto value){
1426 return GetSettings()->Write(key, value.get()) && GetSettings()->Flush();
1427 };
1428 return Visit(visitor, value);
1429}

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

Here is the call graph for this function:

◆ SetDirty()

void PluginManager::SetDirty ( bool  dirty = true)
private

◆ SettingsPath()

RegistryPath PluginManager::SettingsPath ( ConfigurationType  type,
const PluginID ID 
)
private

Definition at line 1432 of file PluginManager.cpp.

1434{
1435 bool shared = (type == ConfigurationType::Shared);
1436
1437 // All the strings reported by PluginDescriptor and used in this function
1438 // persist in the plugin settings configuration file, so they should not
1439 // be changed across Audacity versions, or else compatibility of the
1440 // configuration files will break.
1441
1442 if (auto iter = mRegisteredPlugins.find(ID); iter == mRegisteredPlugins.end())
1443 return {};
1444 else {
1445 const PluginDescriptor & plug = iter->second;
1446
1447 wxString id = GetPluginTypeString(plug.GetPluginType()) +
1448 wxT("_") +
1449 plug.GetEffectFamily() + // is empty for non-Effects
1450 wxT("_") +
1451 plug.GetVendor() +
1452 wxT("_") +
1453 (shared ? wxString{} : plug.GetSymbol().Internal());
1454
1455 return SETROOT +
1456 ConvertID(id) +
1457 wxCONFIG_PATH_SEPARATOR +
1458 (shared ? wxT("shared") : wxT("private")) +
1459 wxCONFIG_PATH_SEPARATOR;
1460 }
1461}
#define SETROOT
const ComponentInterfaceSymbol & GetSymbol() const
PluginType GetPluginType() const
wxString GetEffectFamily() const
const wxString & GetVendor() const

References ConvertID(), PluginDescriptor::GetEffectFamily(), PluginDescriptor::GetPluginType(), GetPluginTypeString(), PluginDescriptor::GetSymbol(), PluginDescriptor::GetVendor(), ComponentInterfaceSymbol::Internal(), mRegisteredPlugins, SETROOT, PluginSettings::Shared, and wxT().

Referenced by Group().

Here is the call graph for this function:
Here is the caller graph for this function:

◆ Terminate()

void PluginManager::Terminate ( )

Definition at line 409 of file PluginManager.cpp.

410{
411 // Get rid of all non-module(effects?) plugins first
412 for(auto& p : mRegisteredPlugins)
413 {
414 auto& desc = p.second;
415 if(desc.GetPluginType() == PluginTypeEffect)
416 mLoadedInterfaces.erase(desc.GetID());
417 }
418
419 // Now get rid of others
420 mRegisteredPlugins.clear();
421 mLoadedInterfaces.clear();
422}

References desc, mLoadedInterfaces, mRegisteredPlugins, and PluginTypeEffect.

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

Here is the caller graph for this function:

◆ UnregisterPlugin()

void PluginManager::UnregisterPlugin ( const PluginID ID)

Definition at line 1024 of file PluginManager.cpp.

1025{
1026 mRegisteredPlugins.erase(ID);
1027 mLoadedInterfaces.erase(ID);
1028}

References mLoadedInterfaces, and mRegisteredPlugins.

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 222 of file PluginManager.h.

◆ mDirty

bool PluginManager::mDirty
private

Definition at line 221 of file PluginManager.h.

◆ mEffectPluginsCleared

std::vector<PluginDescriptor> PluginManager::mEffectPluginsCleared
private

Definition at line 226 of file PluginManager.h.

Referenced by CheckPluginUpdates(), ClearEffectPlugins(), and GetPlugin().

◆ mInstance

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

Definition at line 215 of file PluginManager.h.

Referenced by Get().

◆ mLoadedInterfaces

std::map<PluginID, std::unique_ptr<ComponentInterface> > PluginManager::mLoadedInterfaces
private

Definition at line 225 of file PluginManager.h.

Referenced by IsPluginLoaded(), Load(), RegisterPlugin(), Terminate(), and UnregisterPlugin().

◆ mRegisteredPlugins

PluginMap PluginManager::mRegisteredPlugins
private

◆ mRegver

PluginRegistryVersion PluginManager::mRegver
private

Definition at line 228 of file PluginManager.h.

Referenced by GetRegistryVersion(), Load(), and Save().

◆ mSettings

std::unique_ptr<FileConfig> PluginManager::mSettings
private

Definition at line 219 of file PluginManager.h.

Referenced by GetSettings(), and PluginManager().


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