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)
 
std::vector< std::pair< wxString, 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...
 
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
 

Static Public Member Functions

static PluginManagerGet ()
 
static PluginID GetID (PluginProvider *provider)
 
static PluginID GetID (ComponentInterface *command)
 
static PluginID GetID (const EffectDefinitionInterface *effect)
 
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
 

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

Member Typedef Documentation

◆ FileConfigFactory

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

Definition at line 90 of file PluginManager.h.

Constructor & Destructor Documentation

◆ PluginManager()

PluginManager::PluginManager ( )
private

Definition at line 330 of file PluginManager.cpp.

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

References mSettings.

◆ ~PluginManager()

PluginManager::~PluginManager ( )
private

Definition at line 335 of file PluginManager.cpp.

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

References Terminate().

Here is the call graph for this function:

Member Function Documentation

◆ AllPlugins()

Range PluginManager::AllPlugins ( )
inline

Definition at line 141 of file PluginManager.h.

141{ return { Iterator{ *this } }; }

Referenced by PluginRegistrationDialog::PopulateOrExchange().

Here is the caller graph for this function:

◆ CheckPluginUpdates()

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

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

Returns
Array of pairs, first element of which is provider id and the second is module path

Definition at line 1141 of file PluginManager.cpp.

1142{
1144 wxArrayString pathIndex;
1145 for (auto &pair : mRegisteredPlugins) {
1146 auto &plug = pair.second;
1147
1148 // Bypass 2.1.0 placeholders...remove this after a few releases past 2.1.0
1149 if (plug.GetPluginType() != PluginTypeNone)
1150 pathIndex.push_back(plug.GetPath().BeforeFirst(wxT(';')));
1151 }
1152
1153 // Scan for NEW ones.
1154 //
1155 // Because we use the plugins "path" as returned by the providers, we can actually
1156 // have multiple providers report the same path since, at this point, they only
1157 // know that the path might possibly be one supported by the provider.
1158 //
1159 // When the user enables the plugin, each provider that reported it will be asked
1160 // to register the plugin.
1161
1162 std::vector<std::pair<wxString, wxString>> newPaths;
1163 for (auto &pair : mRegisteredPlugins) {
1164 auto &plug = pair.second;
1165 const PluginID & plugID = plug.GetID();
1166 const wxString & plugPath = plug.GetPath();
1167 PluginType plugType = plug.GetPluginType();
1168
1169 // Bypass 2.1.0 placeholders...remove this after a few releases past 2.1.0
1170 if (plugType == PluginTypeNone)
1171 continue;
1172
1173 if ( plugType == PluginTypeModule )
1174 {
1175 if (!mm.IsProviderValid(plugID, plugPath))
1176 {
1177 plug.SetEnabled(false);
1178 plug.SetValid(false);
1179 }
1180 else
1181 {
1182 if (auto provider = mm.CreateProviderInstance( plugID, plugPath ))
1183 {
1184 const auto paths = provider->FindModulePaths(*this);
1185 for (size_t i = 0, cnt = paths.size(); i < cnt; i++)
1186 {
1187 wxString path = paths[i].BeforeFirst(wxT(';'));
1188 if(!make_iterator_range(pathIndex).contains(path))
1189 newPaths.push_back(std::make_pair(plugID, path));
1190 }
1191 }
1192 }
1193 }
1194 else if (plugType != PluginTypeStub)
1195 {
1196 plug.SetValid(mm.IsPluginValid(plug.GetProviderID(), plugPath, false));
1197 if (!plug.IsValid())
1198 plug.SetEnabled(false);
1199 }
1200 }
1201
1202 return newPaths;
1203}
wxString PluginID
Definition: EffectManager.h:30
IteratorRange< Iterator > make_iterator_range(const Iterator &i1, const Iterator &i2)
Definition: MemoryX.h:423
PluginType
@ PluginTypeStub
@ PluginTypeModule
@ PluginTypeNone
static ModuleManager & Get()
PluginProvider * CreateProviderInstance(const PluginID &provider, const PluginPath &path)
bool IsProviderValid(const PluginID &provider, const PluginPath &path)
bool IsPluginValid(const PluginID &provider, const PluginPath &path, bool bFast)
PluginMap mRegisteredPlugins

References ModuleManager::CreateProviderInstance(), ModuleManager::Get(), ModuleManager::IsPluginValid(), ModuleManager::IsProviderValid(), make_iterator_range(), mRegisteredPlugins, PluginTypeModule, PluginTypeNone, and PluginTypeStub.

Referenced by AudacityApp::InitPart2().

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

1459{
1460 if (ID.StartsWith(wxT("base64:")))
1461 {
1462 wxString id = ID.Mid(7);
1463 ArrayOf<char> buf{ id.length() / 4 * 3 };
1464 id = wxString::FromUTF8(buf.get(), Base64::Decode(id, buf.get()));
1465 return id;
1466 }
1467
1468 const wxCharBuffer & buf = ID.ToUTF8();
1469 return wxT("base64:") + Base64::Encode(buf, strlen(buf));
1470}
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(), 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 1265 of file PluginManager.cpp.

1268{
1269 // This will either create a NEW entry or replace an existing entry
1271
1272 plug.SetPluginType(type);
1273
1274 plug.SetID(id);
1275 plug.SetPath(ident->GetPath());
1276 plug.SetSymbol(ident->GetSymbol());
1277 plug.SetVendor(ident->GetVendor().Internal());
1278 plug.SetVersion(ident->GetVersion());
1279
1280 return plug;
1281}
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
#define XPC(sing, plur, n, c)
Definition: Internat.h:100
#define XO(s)
Definition: Internat.h:31
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:256
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(), XO, and XPC.

Here is the call graph for this function:

◆ EffectsOfType()

Range PluginManager::EffectsOfType ( EffectType  type)
inline

Definition at line 143 of file PluginManager.h.

143{ 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 1100 of file PluginManager.cpp.

1101{
1102 if (auto iter = mRegisteredPlugins.find(ID); iter == mRegisteredPlugins.end())
1103 return;
1104 else
1105 iter->second.SetEnabled(enable);
1106}

References mRegisteredPlugins.

◆ FindFilesInPathList()

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

Implements PluginManagerInterface.

Definition at line 204 of file PluginManager.cpp.

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

Here is the call graph for this function:

◆ Get()

PluginManager & PluginManager::Get ( )
static

Definition at line 377 of file PluginManager.cpp.

378{
379 if (!mInstance)
380 {
382 }
383
384 return *mInstance;
385}
#define safenew
Definition: MemoryX.h:10
PluginManager maintains a list of all plug ins. That covers modules, effects, generators,...
Definition: PluginManager.h:41
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(), EffectManager::GetVendorName(), HandleTextualCommand(), PluginSettings::HasConfigGroup(), PluginSettings::HasConfigValue(), AudacityApp::InitPart2(), anonymous_namespace{EffectManager.cpp}::LoadComponent(), MacroCommandsCatalog::MacroCommandsCatalog(), AudacityApp::OnExit(), PluginRegistrationDialog::OnOK(), PluginStartupRegistration::OnPluginFound(), ProjectFileManager::OpenFile(), anonymous_namespace{PluginMenus.cpp}::PopulateEffectsMenu(), PluginRegistrationDialog::PopulateOrExchange(), EffectManager::RegisterEffect(), PluginSettings::RemoveConfig(), PluginSettings::RemoveConfigSubgroup(), GetInfoCommand::SendCommands(), PluginSettings::SetConfigValue(), anonymous_namespace{RealtimeEffectPanel.cpp}::RealtimeEffectControl::SetEffect(), 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 267 of file PluginManager.cpp.

269{
270 return GetSubgroups(Group(type, ID, group), subgroups);
271}
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 279 of file PluginManager.cpp.

282{
283 return GetConfigValue(Key(type, ID, group, key), var, defval);
284}
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 1360 of file PluginManager.cpp.

1362{
1363 if (key.empty())
1364 return false;
1365 const auto visitor = [&](const auto var){
1366 const auto pVar = &var.get();
1367 // precondition is that defval wraps same type as var
1368 using Type = typename decltype(var)::type;
1369 const auto pDefval =
1370 std::get_if<std::reference_wrapper<const Type>>(&defval);
1371 if constexpr( std::is_same_v<Type, float> ) {
1372 double temp;
1373 if( GetSettings()->Read(key, &temp, *pDefval) ) {
1374 *pVar = static_cast<float>(temp);
1375 return true;
1376 }
1377 return false;
1378 }
1379 else
1380 return GetSettings()->Read(key, pVar, *pDefval);
1381 };
1382 return Visit(visitor, var);
1383}
auto Visit(Visitor &&vis, Variant &&var)
Mimic some of std::visit, for the case of one visitor only.
Definition: MemoryX.h:570
FileConfig * GetSettings()

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

Here is the call graph for this function:

◆ GetID() [1/3]

PluginID PluginManager::GetID ( ComponentInterface command)
static

Definition at line 1210 of file PluginManager.cpp.

1211{
1212 return wxString::Format(wxT("%s_%s_%s_%s_%s"),
1214 wxEmptyString,
1215 command->GetVendor().Internal(),
1216 command->GetSymbol().Internal(),
1217 command->GetPath());
1218}
@ 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(), and PluginTypeAudacityCommand.

Here is the call graph for this function:

◆ GetID() [2/3]

PluginID PluginManager::GetID ( const EffectDefinitionInterface effect)
static

Definition at line 1220 of file PluginManager.cpp.

1221{
1222 return wxString::Format(wxT("%s_%s_%s_%s_%s"),
1224 effect->GetFamily().Internal(),
1225 effect->GetVendor().Internal(),
1226 effect->GetSymbol().Internal(),
1227 effect->GetPath());
1228}
@ PluginTypeEffect
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 1205 of file PluginManager.cpp.

1206{
1207 return ModuleManager::GetID(provider);
1208}
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 1031 of file PluginManager.cpp.

1032{
1033 if (auto iter = mRegisteredPlugins.find(ID); iter == mRegisteredPlugins.end())
1034 return nullptr;
1035 else
1036 return &iter->second;
1037}

References mRegisteredPlugins.

Referenced by anonymous_namespace{PluginMenus.cpp}::AddEffectMenuItemGroup(), MacroCommands::ApplyEffectCommand(), MacroCommands::DoAudacityCommand(), EffectUI::DoEffect(), GetPluginEnabledSetting(), anonymous_namespace{RealtimeEffectPanel.cpp}::RealtimeEffectControl::SetEffect(), 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 1025 of file PluginManager.cpp.

1026{
1027 return count_if(mRegisteredPlugins.begin(), mRegisteredPlugins.end(), [type](auto &pair){
1028 return pair.second.GetPluginType() == type; });
1029}

References mRegisteredPlugins.

◆ GetPluginEnabledSetting() [1/2]

RegistryPath PluginManager::GetPluginEnabledSetting ( const PluginDescriptor desc) const

Definition at line 112 of file PluginManager.cpp.

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

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

105{
106 auto pPlugin = GetPlugin( ID );
107 if ( pPlugin )
108 return GetPluginEnabledSetting( *pPlugin );
109 return {};
110}
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 1232 of file PluginManager.cpp.

1233{
1234 wxString str;
1235
1236 switch (type)
1237 {
1238 default:
1239 case PluginTypeNone:
1240 str = wxT("Placeholder");
1241 break;
1242 case PluginTypeStub:
1243 str = wxT("Stub");
1244 break;
1245 case PluginTypeEffect:
1246 str = wxT("Effect");
1247 break;
1249 str = wxT("Generic");
1250 break;
1251 case PluginTypeExporter:
1252 str = wxT("Exporter");
1253 break;
1254 case PluginTypeImporter:
1255 str = wxT("Importer");
1256 break;
1257 case PluginTypeModule:
1259 break;
1260 }
1261
1262 return str;
1263}
#define str(a)
@ PluginTypeExporter
@ PluginTypeImporter
static wxString GetPluginTypeString()

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

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

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

◆ GetSettings()

FileConfig * PluginManager::GetSettings ( )
private

Definition at line 1283 of file PluginManager.cpp.

1284{
1285 if (!mSettings)
1286 {
1288
1289 // Check for a settings version that we can understand
1290 if (mSettings->HasEntry(SETVERKEY))
1291 {
1292 wxString setver = mSettings->Read(SETVERKEY, SETVERKEY);
1293 if (setver < SETVERCUR )
1294 {
1295 // This is where we'd put in conversion code when the
1296 // settings version changes.
1297 //
1298 // Should also check for a settings file that is newer than
1299 // what we can understand.
1300 }
1301 }
1302 else
1303 {
1304 // Make sure is has a version string
1305 mSettings->Write(SETVERKEY, SETVERCUR);
1306 mSettings->Flush();
1307 }
1308 }
1309
1310 return mSettings.get();
1311}
#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 1330 of file PluginManager.cpp.

1331{
1332 if (group.empty() || !HasGroup(group))
1333 {
1334 return false;
1335 }
1336
1337 wxString path = GetSettings()->GetPath();
1338 GetSettings()->SetPath(group);
1339
1340 wxString name;
1341 long index = 0;
1342 if (GetSettings()->GetFirstGroup(name, index))
1343 {
1344 do
1345 {
1346 subgroups.push_back(name);
1347 } while (GetSettings()->GetNextGroup(name, index));
1348 }
1349
1350 GetSettings()->SetPath(path);
1351
1352 return true;
1353}
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 1108 of file PluginManager.cpp.

1109{
1110 if (auto iter = mRegisteredPlugins.find(ID); iter == mRegisteredPlugins.end()) {
1111 static ComponentInterfaceSymbol empty;
1112 return empty;
1113 }
1114 else
1115 return iter->second.GetSymbol();
1116}
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 1429 of file PluginManager.cpp.

1431{
1432 auto path = SettingsPath(type, ID);
1433
1434 wxFileName ff(group);
1435 if (!ff.GetName().empty())
1436 {
1437 path += ff.GetFullPath(wxPATH_UNIX) + wxCONFIG_PATH_SEPARATOR;
1438 }
1439
1440 return path;
1441}
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 261 of file PluginManager.cpp.

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

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

275{
276 return HasConfigValue(Key(type, ID, group, key));
277}
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 1355 of file PluginManager.cpp.

1356{
1357 return GetSettings()->Exists(key);
1358}

References GetSettings(), and key.

Here is the call graph for this function:

◆ HasGroup()

bool PluginManager::HasGroup ( const RegistryPath group)
private

Definition at line 1313 of file PluginManager.cpp.

1314{
1315 auto settings = GetSettings();
1316
1317 bool res = settings->HasGroup(group);
1318 if (res)
1319 {
1320 // The group exists, but empty groups aren't considered valid
1321 wxString oldPath = settings->GetPath();
1322 settings->SetPath(group);
1323 res = settings->GetNumberOfEntries() || settings->GetNumberOfGroups();
1324 settings->SetPath(oldPath);
1325 }
1326
1327 return res;
1328}
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 387 of file PluginManager.cpp.

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

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

342{
344
345 // Check all known plugins to ensure they are still valid.
346 for (auto &pair : mRegisteredPlugins) {
347 auto &plug = pair.second;
348 const wxString & plugPath = plug.GetPath();
349 PluginType plugType = plug.GetPluginType();
350
351 if (plugType != PluginTypeNone && plugType != PluginTypeStub && plugType != PluginTypeModule)
352 {
353 plug.SetValid(mm.IsPluginValid(plug.GetProviderID(), plugPath, true));
354 if (!plug.IsValid())
355 {
356 plug.SetEnabled(false);
357 }
358 }
359 }
360
361 Save();
362}

References ModuleManager::Get(), ModuleManager::IsPluginValid(), mRegisteredPlugins, PluginTypeModule, PluginTypeNone, PluginTypeStub, 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 1092 of file PluginManager.cpp.

1093{
1094 if (auto iter = mRegisteredPlugins.find(ID); iter == mRegisteredPlugins.end())
1095 return false;
1096 else
1097 return iter->second.IsEnabled();
1098}

References mRegisteredPlugins.

◆ IsPluginLoaded()

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

Definition at line 149 of file PluginManager.cpp.

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

References mLoadedInterfaces.

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

Here is the caller graph for this function:

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

137{
138 for (auto &pair : mRegisteredPlugins) {
139 if (auto &descriptor = pair.second; descriptor.GetPath() == path) {
140 if (pName)
141 descriptor.SetSymbol(
142 { descriptor.GetSymbol().Internal(), *pName });
143 return true;
144 }
145 }
146 return false;
147}
@ 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 1444 of file PluginManager.cpp.

1446{
1447 auto path = Group(type, ID, group);
1448 if (path.empty())
1449 {
1450 return path;
1451 }
1452
1453 return path + key;
1454}

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 wxString regver = registry.Read(REGVERKEY);
561 if (regver < REGVERCUR )
562 {
563 // Conversion code here, for when registry version changes.
564
565 // We iterate through the effects, possibly updating their info.
566 wxString groupName;
567 long groupIndex;
568 wxString group = GetPluginTypeString(PluginTypeEffect);
569 wxString cfgPath = REGROOT + group + wxCONFIG_PATH_SEPARATOR;
570 wxArrayString groupsToDelete;
571
572 registry.SetPath(cfgPath);
573 for (bool cont = registry.GetFirstGroup(groupName, groupIndex);
574 cont;
575 registry.SetPath(cfgPath),
576 cont = registry.GetNextGroup(groupName, groupIndex))
577 {
578 registry.SetPath(groupName);
579 wxString effectSymbol = registry.Read(KEY_SYMBOL, "");
580 wxString effectVersion = registry.Read(KEY_VERSION, "");
581
582
583 // For 2.3.0 the plugins we distribute have moved around.
584 // So we upped the registry version number to 1.1.
585 // These particular config edits were originally written to fix Bug 1914.
586 if (regver <= "1.0") {
587 // Nyquist prompt is a built-in that has moved to the tools menu.
588 if (effectSymbol == NYQUIST_PROMPT_ID) {
589 registry.Write(KEY_EFFECTTYPE, "Tool");
590 // Old version of SDE was in Analyze menu. Now it is in Tools.
591 // We don't want both the old and the new.
592 } else if ((effectSymbol == "Sample Data Export") && (effectVersion == "n/a")) {
593 groupsToDelete.push_back(cfgPath + groupName);
594 // Old version of SDI was in Generate menu. Now it is in Tools.
595 } else if ((effectSymbol == "Sample Data Import") && (effectVersion == "n/a")) {
596 groupsToDelete.push_back(cfgPath + groupName);
597 }
598 }
599
600 }
601 // Doing the deletion within the search loop risked skipping some items,
602 // hence the delayed delete.
603 for (unsigned int i = 0; i < groupsToDelete.size(); i++) {
604 registry.DeleteGroup(groupsToDelete[i]);
605 }
606 registry.SetPath("");
607 registry.Write(REGVERKEY, REGVERCUR);
608 // Updates done. Make sure we read the updated data later.
609 registry.Flush();
610 }
611
612 // Load all provider plugins first
613 LoadGroup(&registry, PluginTypeModule);
614
615 // Now the rest
616 LoadGroup(&registry, PluginTypeEffect);
618 LoadGroup(&registry, PluginTypeExporter);
619 LoadGroup(&registry, PluginTypeImporter);
620
621 LoadGroup(&registry, PluginTypeStub);
622 return;
623}
#define REGVERKEY
#define KEY_SYMBOL
#define REGROOT
#define KEY_VERSION
#define KEY_EFFECTTYPE
#define REGVERCUR
#define NYQUIST_PROMPT_ID
void LoadGroup(FileConfig *pRegistry, PluginType type)
FILES_API FilePath PluginRegistry()

References GetPluginTypeString(), KEY_EFFECTTYPE, KEY_SYMBOL, KEY_VERSION, LoadGroup(), NYQUIST_PROMPT_ID, FileNames::PluginRegistry(), PluginTypeAudacityCommand, PluginTypeEffect, PluginTypeExporter, PluginTypeImporter, PluginTypeModule, PluginTypeStub, REGROOT, REGVERCUR, 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 1118 of file PluginManager.cpp.

1119{
1120 if(auto it = mLoadedInterfaces.find(ID); it != mLoadedInterfaces.end())
1121 return it->second.get();
1122
1123 if(auto it = mRegisteredPlugins.find(ID); it != mRegisteredPlugins.end())
1124 {
1125 auto& desc = it->second;
1126 if(desc.GetPluginType() == PluginTypeModule)
1127 //it's very likely that this code path is not used
1128 return ModuleManager::Get().CreateProviderInstance(desc.GetID(), desc.GetPath());
1129
1130 if(auto provider = ModuleManager::Get().CreateProviderInstance(desc.GetProviderID(), wxEmptyString))
1131 {
1132 auto pluginInterface = provider->LoadPlugin(desc.GetPath());
1133 auto result = pluginInterface.get();
1134 mLoadedInterfaces[desc.GetID()] = std::move(pluginInterface);
1135 return result;
1136 }
1137 }
1138 return nullptr;
1139}
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 625 of file PluginManager.cpp.

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

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, mRegisteredPlugins, 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 142 of file PluginManager.h.

142{ 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 154 of file PluginManager.cpp.

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

References desc, and mRegisteredPlugins.

Referenced by PluginManagerInterface::AudacityCommandRegistrationCallback(), PluginManagerInterface::DefaultRegistrationCallback(), Initialize(), PluginStartupRegistration::OnPluginFound(), 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 159 of file PluginManager.cpp.

160{
161 PluginDescriptor & plug =
162 CreatePlugin(GetID(provider), provider, PluginTypeModule);
164
165 plug.SetEnabled(true);
166 plug.SetValid(true);
167
168 return plug.GetID();
169}
const wxString & GetID() const
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 171 of file PluginManager.cpp.

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

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

186{
187 PluginDescriptor & plug = CreatePlugin(GetID(effect), effect, (PluginType)type);
188
189 plug.SetProviderID(PluginManager::GetID(provider));
190
191 plug.SetEffectType(effect->GetClassification());
192 plug.SetEffectFamily(effect->GetFamily().Internal());
193 plug.SetEffectInteractive(effect->IsInteractive());
194 plug.SetEffectDefault(effect->IsDefault());
195 plug.SetEffectRealtime(effect->SupportsRealtime());
197
198 plug.SetEnabled(true);
199 plug.SetValid(true);
200
201 return plug.GetID();
202}
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 SupportsRealtime() const =0
Whether the effect supports realtime previewing (while audio is playing).
virtual bool SupportsAutomation() const =0
Whether the effect has any automatable controls.

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() [5/5]

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

Used only by Nyquist Workbench module.

Definition at line 997 of file PluginManager.cpp.

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

References CreatePlugin(), PluginDescriptor::GetID(), GetID(), mLoadedInterfaces, PluginDescriptor::SetEffectAutomatable(), PluginDescriptor::SetEffectDefault(), PluginDescriptor::SetEffectFamily(), PluginDescriptor::SetEffectInteractive(), PluginDescriptor::SetEffectLegacy(), PluginDescriptor::SetEffectRealtime(), PluginDescriptor::SetEffectType(), PluginDescriptor::SetEnabled(), 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 305 of file PluginManager.cpp.

307{
308 bool result = GetSettings()->DeleteEntry(Key(type, ID, group, key));
309 if (result)
310 {
311 GetSettings()->Flush();
312 }
313
314 return result;
315}
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 293 of file PluginManager.cpp.

295{
296 bool result = GetSettings()->DeleteGroup(Group(type, ID, group));
297 if (result)
298 {
299 GetSettings()->Flush();
300 }
301
302 return result;
303}
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 882 of file PluginManager.cpp.

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

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

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

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

289{
290 return SetConfigValue(Key(type, ID, group, key), value);
291}
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 1385 of file PluginManager.cpp.

1387{
1388 if (key.empty())
1389 return false;
1390 const auto visitor = [&](const auto value){
1391 return GetSettings()->Write(key, value.get()) && GetSettings()->Flush();
1392 };
1393 return Visit(visitor, value);
1394}

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

1399{
1400 bool shared = (type == ConfigurationType::Shared);
1401
1402 // All the strings reported by PluginDescriptor and used in this function
1403 // persist in the plugin settings configuration file, so they should not
1404 // be changed across Audacity versions, or else compatibility of the
1405 // configuration files will break.
1406
1407 if (auto iter = mRegisteredPlugins.find(ID); iter == mRegisteredPlugins.end())
1408 return {};
1409 else {
1410 const PluginDescriptor & plug = iter->second;
1411
1412 wxString id = GetPluginTypeString(plug.GetPluginType()) +
1413 wxT("_") +
1414 plug.GetEffectFamily() + // is empty for non-Effects
1415 wxT("_") +
1416 plug.GetVendor() +
1417 wxT("_") +
1418 (shared ? wxString{} : plug.GetSymbol().Internal());
1419
1420 return SETROOT +
1421 ConvertID(id) +
1422 wxCONFIG_PATH_SEPARATOR +
1423 (shared ? wxT("shared") : wxT("private")) +
1424 wxCONFIG_PATH_SEPARATOR;
1425 }
1426}
#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, and PluginSettings::Shared.

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

409{
410 // Get rid of all non-module(effects?) plugins first
411 auto iter = mRegisteredPlugins.begin();
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 1019 of file PluginManager.cpp.

1020{
1021 mRegisteredPlugins.erase(ID);
1022 mLoadedInterfaces.erase(ID);
1023}

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

◆ mDirty

bool PluginManager::mDirty
private

Definition at line 210 of file PluginManager.h.

◆ mInstance

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

Definition at line 204 of file PluginManager.h.

Referenced by Get().

◆ mLoadedInterfaces

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

Definition at line 214 of file PluginManager.h.

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

◆ mRegisteredPlugins

PluginMap PluginManager::mRegisteredPlugins
private

◆ mSettings

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

Definition at line 208 of file PluginManager.h.

Referenced by GetSettings(), and PluginManager().


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