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 ConfigFactory = std::function< std::unique_ptr< audacity::BasicSettings >(const FilePath &localFilename) >
 
- Public Types inherited from PluginManagerInterface
using ConfigurationType = PluginSettings::ConfigurationType
 
using ConfigReference = PluginSettings::ConfigReference
 
using ConfigConstReference = PluginSettings::ConfigConstReference
 
- Public Types inherited from Observer::Publisher< PluginsChangedMessage >
using message_type = PluginsChangedMessage
 
using CallbackReturn = std::conditional_t< true, void, bool >
 
using Callback = std::function< CallbackReturn(const PluginsChangedMessage &) >
 Type of functions that can be connected to the Publisher. More...
 

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 (ConfigFactory 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...
 
void NotifyPluginsChanged ()
 
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...
 
- Public Member Functions inherited from Observer::Publisher< PluginsChangedMessage >
 Publisher (ExceptionPolicy *pPolicy=nullptr, Alloc a={})
 Constructor supporting type-erased custom allocation/deletion. More...
 
 Publisher (Publisher &&)=default
 
Publisheroperator= (Publisher &&)=default
 
Subscription Subscribe (Callback callback)
 Connect a callback to the Publisher; later-connected are called earlier. More...
 
Subscription Subscribe (Object &obj, Return(Object::*callback)(Args...))
 Overload of Subscribe takes an object and pointer-to-member-function. 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 bool IsPluginAvailable (const PluginDescriptor &plug)
 
- 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 (audacity::BasicSettings *pRegistry, PluginType type)
 
void SaveGroup (audacity::BasicSettings *pRegistry, PluginType type)
 
PluginDescriptorCreatePlugin (const PluginID &id, ComponentInterface *ident, PluginType type)
 
audacity::BasicSettingsGetSettings ()
 
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< audacity::BasicSettingsmSettings
 
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 {}
 

Additional Inherited Members

- Static Public Attributes inherited from Observer::Publisher< PluginsChangedMessage >
static constexpr bool notifies_all
 
- Protected Member Functions inherited from Observer::Publisher< PluginsChangedMessage >
CallbackReturn Publish (const PluginsChangedMessage &message)
 Send a message to connected callbacks. More...
 

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

Member Typedef Documentation

◆ ConfigFactory

using PluginManager::ConfigFactory = std::function< std::unique_ptr<audacity::BasicSettings>(const FilePath &localFilename ) >

Definition at line 100 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< audacity::BasicSettings > 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 157 of file PluginManager.h.

157{ return { Iterator{ *this } }; }

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

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

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

References _, anonymous_namespace{ExportPCM.cpp}::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 1495 of file PluginManager.cpp.

1496{
1497 if (ID.StartsWith(wxT("base64:")))
1498 {
1499 wxString id = ID.Mid(7);
1500 ArrayOf<char> buf{ id.length() / 4 * 3 };
1501 id = wxString::FromUTF8(buf.get(), Base64::Decode(id, buf.get()));
1502 return id;
1503 }
1504
1505 const wxCharBuffer & buf = ID.ToUTF8();
1506 return wxT("base64:") + Base64::Encode(buf, strlen(buf));
1507}
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 1322 of file PluginManager.cpp.

1325{
1326 // This will either create a NEW entry or replace an existing entry
1328
1329 plug.SetPluginType(type);
1330
1331 plug.SetID(id);
1332 plug.SetPath(ident->GetPath());
1333 plug.SetSymbol(ident->GetSymbol());
1334 plug.SetVendor(ident->GetVendor().Internal());
1335 plug.SetVersion(ident->GetVersion());
1336
1337 return plug;
1338}
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 425 of file PluginManager.cpp.

426{
427 using namespace BasicUI;
428 auto &mm = ModuleManager::Get();
429 const wxFileName src{ fileName };
430
431 for (auto &plug : PluginsOfType(PluginTypeModule)) {
432 auto module = static_cast<PluginProvider *>
433 (mm.CreateProviderInstance(plug.GetID(), plug.GetPath()));
434 if (! module)
435 continue;
436
437 const auto &ff = module->InstallPath();
438 const auto &extensions = module->GetFileExtensions();
439 if ( !ff.empty() &&
440 extensions.Index(src.GetExt(), false) != wxNOT_FOUND ) {
441 TranslatableString errMsg;
442 // Do dry-run test of the file format
443 unsigned nPlugIns =
444 module->DiscoverPluginsAtPath(fileName, errMsg, {});
445 if (nPlugIns) {
446 // File contents are good for this module, so check no others.
447 // All branches of this block return true, even in case of
448 // failure for other reasons, to signal that other drag-and-drop
449 // actions should not be tried.
450
451 // Find path to copy it
452 wxFileName dst;
453 dst.AssignDir( ff );
454 dst.SetFullName( src.GetFullName() );
455 if ( dst.Exists() ) {
456 // Query whether to overwrite
457 bool overwrite = (MessageBoxResult::Yes == ShowMessageBox(
458 XO("Overwrite the plug-in file %s?")
459 .Format( dst.GetFullPath() ),
461 .Caption(XO("Plug-in already exists"))
462 .ButtonStyle(Button::YesNo)));
463 if ( !overwrite )
464 return true;
465 }
466
467 // Move the file or subtree
468 bool copied = false;
469 auto dstPath = dst.GetFullPath();
470 if ( src.FileExists() )
471 // A simple one-file plug-in
472 copied = FileNames::DoCopyFile(
473 src.GetFullPath(), dstPath, true );
474 else {
475 // A sub-folder
476 // such as for some VST packages
477 // Recursive copy needed -- to do
478 return true;
479 }
480
481 if (!copied) {
483 XO("Plug-in file is in use. Failed to overwrite") );
484 return true;
485 }
486
487 // Register for real
488 std::vector<PluginID> ids;
489 std::vector<wxString> names;
490 nPlugIns = module->DiscoverPluginsAtPath(dstPath, errMsg,
492 -> const PluginID& {
493 // Register as by default, but also collecting the PluginIDs
494 // and names
496 provider, ident);
497 ids.push_back(id);
498 names.push_back( ident->GetSymbol().Translation() );
499 return id;
500 });
501 if ( ! nPlugIns ) {
502 // Unlikely after the dry run succeeded
504 XO("Failed to register:\n%s").Format( errMsg ) );
505 return true;
506 }
507
508 // Ask whether to enable the plug-ins
509 if (auto nIds = ids.size()) {
510 auto message = XPC(
511 /* i18n-hint A plug-in is an optional added program for a sound
512 effect, or generator, or analyzer */
513 "Enable this plug-in?\n",
514 "Enable these plug-ins?\n",
515 0,
516 "plug-ins"
517 )( nIds );
518 for (const auto &name : names)
519 message.Join( Verbatim( name ), wxT("\n") );
520 bool enable = (MessageBoxResult::Yes == ShowMessageBox(
521 message,
523 .Caption(XO("Enable new plug-ins"))
524 .ButtonStyle(Button::YesNo)));
525 for (const auto &id : ids)
526 mRegisteredPlugins[id].SetEnabled(enable);
527 // Make changes to enabled status persist:
528 this->Save();
529 this->NotifyPluginsChanged();
530 }
531
532 return true;
533 }
534 }
535 }
536
537 return false;
538}
wxString PluginID
const TranslatableString name
Definition: Distortion.cpp:76
XO("Cut/Copy/Paste")
#define XPC(sing, plur, n, c)
Definition: Internat.h:98
@ PluginTypeModule
static TranslatableStrings names
Definition: TagsEditor.cpp:153
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)
void NotifyPluginsChanged()
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:277
FILES_API bool DoCopyFile(const FilePath &file1, const FilePath &file2, bool overwrite=true)
MessageBoxOptions && Caption(TranslatableString caption_) &&
Definition: BasicUI.h:101

References BasicUI::MessageBoxOptions::Caption(), PluginManagerInterface::DefaultRegistrationCallback(), FileNames::DoCopyFile(), ModuleManager::Get(), id, ident(), PluginProvider::InstallPath(), mRegisteredPlugins, name, names, NotifyPluginsChanged(), 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 159 of file PluginManager.h.

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

Referenced by MenuHelper::PopulateEffectsMenu().

Here is the caller graph for this function:

◆ EnablePlugin()

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

Definition at line 1105 of file PluginManager.cpp.

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

References mRegisteredPlugins.

Referenced by BuiltinEffectsModule::AutoRegisterPlugins().

Here is the caller graph for this function:

◆ 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(), FileNames::PlugInDir(), and wxT().

Here is the call graph for this function:

◆ Get()

PluginManager & PluginManager::Get ( )
static

Definition at line 379 of file PluginManager.cpp.

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

References mInstance, and safenew.

Referenced by anonymous_namespace{MenuHelper.cpp}::AddEffectMenuItemGroup(), PluginDataModel::ApplyChanges(), MacroCommands::ApplyEffectCommand(), PluginManagerInterface::AudacityCommandRegistrationCallback(), BuiltinEffectsModule::AutoRegisterPlugins(), PluginManagerInterface::DefaultRegistrationCallback(), anonymous_namespace{PluginHost.cpp}::Discover(), CommandDispatch::DoAudacityCommand(), EffectUI::DoEffect(), anonymous_namespace{PluginMenus.cpp}::DoManagePluginsMenu(), EffectManager::GetAudacityCommand(), EffectManager::GetCommandIdentifier(), EffectManager::GetCommandSymbol(), PluginSettings::GetConfigSubgroups(), PluginSettings::GetConfigValue(), EffectManager::GetEffectByIdentifier(), EffectManager::GetEffectFamilyName(), anonymous_namespace{RealtimeEffectPanel.cpp}::RealtimeEffectControl::GetPlugin(), EffectManager::GetVendorName(), CommandDispatch::HandleTextualCommand(), PluginSettings::HasConfigGroup(), PluginSettings::HasConfigValue(), AudacityApp::InitPart2(), anonymous_namespace{MenuHelper.cpp}::IsEnabledPlugin(), anonymous_namespace{EffectManager.cpp}::LoadComponent(), MacroCommandsCatalog::MacroCommandsCatalog(), RealtimeEffectListWindow::OnAddEffectClicked(), AudacityApp::OnExit(), anonymous_namespace{FileMenus.cpp}::OnOpen(), PluginStartupRegistration::OnPluginFound(), PluginRegistrationDialog::OnRescan(), PluginStartupRegistration::OnValidationFinished(), ProjectFileManager::OpenFile(), PluginDataModel::PluginDataModel(), MenuHelper::PopulateEffectsMenu(), RealtimeEffectListWindow::RealtimeEffectListWindow(), EffectManager::RegisterEffect(), PluginSettings::RemoveConfig(), PluginSettings::RemoveConfigSubgroup(), PluginStartupRegistration::Run(), GetInfoCommand::SendCommands(), PluginSettings::SetConfigValue(), 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 1402 of file PluginManager.cpp.

1404{
1405 using namespace Variant;
1406 if (key.empty())
1407 return false;
1408 const auto visitor = [&](const auto var){
1409 const auto pVar = &var.get();
1410 // precondition is that defval wraps same type as var
1411 using Type = typename decltype(var)::type;
1412 const auto pDefval =
1413 std::get_if<std::reference_wrapper<const Type>>(&defval);
1414 //TD<decltype(pDefval)> defType;
1415 //return true;
1416 return GetSettings()->Read(key, pVar, pDefval->get());
1417 };
1418 return Visit(visitor, var);
1419}
audacity::BasicSettings * GetSettings()
virtual bool Read(const wxString &key, bool *value) const =0
MENUS_API void Visit(Visitor< Traits > &visitor, AudacityProject &project)

References GetSettings(), key, audacity::BasicSettings::Read(), and MenuRegistry::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 1259 of file PluginManager.cpp.

1260{
1261 auto strings = wxSplit(ID, '_');
1262 if (strings.size() == 5)
1263 return strings[3];
1264 return {};
1265}

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

1229{
1230 return wxString::Format(wxT("%s_%s_%s_%s_%s"),
1232 wxEmptyString,
1233 command->GetVendor().Internal(),
1234 command->GetSymbol().Internal(),
1235 command->GetPath());
1236}
@ 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 1248 of file PluginManager.cpp.

1249{
1250 return wxJoin(wxArrayStringEx{
1252 effect->GetFamily().Internal(),
1253 effect->GetVendor().Internal(),
1254 effect->GetSymbol().Internal(),
1255 effect->GetPath()
1256 }, '_');
1257}
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 1223 of file PluginManager.cpp.

1224{
1225 return ModuleManager::GetID(provider);
1226}
static PluginID GetID(PluginProvider *provider)

References ModuleManager::GetID().

Referenced by GetID(), PluginRegistrationDialog::PopulateOrExchange(), 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 1029 of file PluginManager.cpp.

1030{
1031 if (auto iter = mRegisteredPlugins.find(ID); iter != mRegisteredPlugins.end())
1032 return &iter->second;
1033
1035 .find_if([&ID](const PluginDescriptor& plug) {
1036 return plug.GetID() == ID;
1037 });
1038 if (iter2 != mEffectPluginsCleared.end())
1039 return &(*iter2);
1040
1041 return nullptr;
1042}
const wxString & GetID() const

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

Referenced by anonymous_namespace{MenuHelper.cpp}::AddEffectMenuItemGroup(), MacroCommands::ApplyEffectCommand(), CommandDispatch::DoAudacityCommand(), EffectUI::DoEffect(), anonymous_namespace{RealtimeEffectPanel.cpp}::RealtimeEffectControl::GetPlugin(), GetPluginEnabledSetting(), RealtimeEffectListWindow::OnAddEffectClicked(), anonymous_namespace{FileMenus.cpp}::OnOpen(), 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 1023 of file PluginManager.cpp.

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

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}
RegistryPath GetPluginEnabledSetting(const PluginID &ID) const

References anonymous_namespace{ExportPCM.cpp}::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 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 1269 of file PluginManager.cpp.

1270{
1271 wxString str;
1272
1273 switch (type)
1274 {
1275 default:
1276 case PluginTypeNone:
1277 str = wxT("Placeholder");
1278 break;
1279 case PluginTypeStub:
1280 str = wxT("Stub");
1281 break;
1282 case PluginTypeEffect:
1283 str = wxT("Effect");
1284 break;
1286 str = wxT("Generic");
1287 break;
1288 case PluginTypeExporter:
1289 str = wxT("Exporter");
1290 break;
1291 case PluginTypeImporter:
1292 str = wxT("Importer");
1293 break;
1294 case PluginTypeModule:
1296 break;
1297 }
1298
1299 return str;
1300}
#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 905 of file PluginManager.cpp.

906{
907 return mRegver;
908}
PluginRegistryVersion mRegver

References mRegver.

◆ GetSettings()

audacity::BasicSettings * PluginManager::GetSettings ( )
private

Definition at line 1340 of file PluginManager.cpp.

1341{
1342 if (!mSettings)
1343 {
1345
1346 // Check for a settings version that we can understand
1347 if (mSettings->HasEntry(SETVERKEY))
1348 {
1349 wxString setver = mSettings->Read(SETVERKEY, SETVERKEY);
1350 if (setver < SETVERCUR )
1351 {
1352 // This is where we'd put in conversion code when the
1353 // settings version changes.
1354 //
1355 // Should also check for a settings file that is newer than
1356 // what we can understand.
1357 }
1358 }
1359 else
1360 {
1361 // Make sure is has a version string
1362 mSettings->Write(SETVERKEY, SETVERCUR);
1363 mSettings->Flush();
1364 }
1365 }
1366
1367 return mSettings.get();
1368}
static PluginManager::ConfigFactory sFactory
#define SETVERKEY
#define SETVERCUR
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 1381 of file PluginManager.cpp.

1382{
1383 if (groupName.empty() || !HasGroup(groupName))
1384 {
1385 return false;
1386 }
1387
1388 auto group = GetSettings()->BeginGroup(groupName);
1389 for(const auto& name : GetSettings()->GetChildGroups())
1390 subgroups.push_back(name);
1391
1392 return true;
1393}
bool HasGroup(const RegistryPath &group)
GroupScope BeginGroup(const wxString &prefix)
Appends a prefix to the current group or sets a new absolute path. Group that was set as current befo...

References audacity::BasicSettings::BeginGroup(), GetSettings(), HasGroup(), and name.

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

1114{
1115 if (auto iter = mRegisteredPlugins.find(ID); iter == mRegisteredPlugins.end()) {
1116 static ComponentInterfaceSymbol empty;
1117 return empty;
1118 }
1119 else
1120 return iter->second.GetSymbol();
1121}
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 1466 of file PluginManager.cpp.

1468{
1469 auto path = SettingsPath(type, ID);
1470
1471 wxFileName ff(group);
1472 if (!ff.GetName().empty())
1473 {
1474 path += ff.GetFullPath(wxPATH_UNIX) + wxCONFIG_PATH_SEPARATOR;
1475 }
1476
1477 return path;
1478}
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 1395 of file PluginManager.cpp.

1396{
1397 return GetSettings()->Exists(key);
1398}
virtual bool Exists(const wxString &key) const
Returns true if group or entry exists.

References audacity::BasicSettings::Exists(), GetSettings(), and key.

Here is the call graph for this function:

◆ HasGroup()

bool PluginManager::HasGroup ( const RegistryPath group)
private

Definition at line 1370 of file PluginManager.cpp.

1371{
1372 auto settings = GetSettings();
1373
1374 if(!settings->HasGroup(groupName))
1375 return false;
1376
1377 auto group = settings->BeginGroup(groupName);
1378 return !settings->GetChildGroups().empty() || !settings->GetChildKeys().empty();
1379}
static Settings & settings()
Definition: TrackInfo.cpp:69

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 ( ConfigFactory  factory)
Precondition
factory != nullptr

Definition at line 389 of file PluginManager.cpp.

390{
391 sFactory = move(factory);
392
393 // Always load the registry first
394 Load();
395
396 // And force load of setting to verify it's accessible
397 GetSettings();
398
399 auto &mm = ModuleManager::Get();
400 mm.DiscoverProviders();
401 for (auto& [id, module] : mm.Providers()) {
402 RegisterPlugin(module.get());
403 // Allow the module to auto-register children
404 module->AutoRegisterPlugins(*this);
405 }
406
408}
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 341 of file PluginManager.cpp.

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

◆ IsPluginAvailable()

bool PluginManager::IsPluginAvailable ( const PluginDescriptor plug)
static

Definition at line 1302 of file PluginManager.cpp.

1303{
1304 const auto& providerID = plug.GetProviderID();
1305 auto provider = ModuleManager::Get().CreateProviderInstance(providerID, wxEmptyString);
1306
1307 if (provider == nullptr)
1308 {
1309 wxLogWarning("Unable to find a provider for '%s'", providerID);
1310 return false;
1311 }
1312
1313 if (provider->CheckPluginExist(plug.GetPath()) == false)
1314 {
1315 wxLogWarning("Plugin '%s' does not exist", plug.GetID());
1316 return false;
1317 }
1318
1319 return true;
1320}
PluginProvider * CreateProviderInstance(const PluginID &provider, const PluginPath &path)
const wxString & GetProviderID() const

References ModuleManager::CreateProviderInstance(), ModuleManager::Get(), PluginDescriptor::GetID(), PluginDescriptor::GetPath(), and PluginDescriptor::GetProviderID().

Referenced by EffectUI::DoEffect(), RealtimeEffectListWindow::OnAddEffectClicked(), and anonymous_namespace{FileMenus.cpp}::OnOpen().

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

◆ IsPluginEnabled()

bool PluginManager::IsPluginEnabled ( const PluginID ID)

Definition at line 1097 of file PluginManager.cpp.

1098{
1099 if (auto iter = mRegisteredPlugins.find(ID); iter == mRegisteredPlugins.end())
1100 return false;
1101 else
1102 return iter->second.IsEnabled();
1103}

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.

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

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

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

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

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

References ModuleManager::CreateProviderInstance(), anonymous_namespace{ExportPCM.cpp}::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 ( audacity::BasicSettings pRegistry,
PluginType  type 
)
private

Definition at line 618 of file PluginManager.cpp.

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

References audacity::BasicSettings::BeginGroup(), ConvertID(), PluginDescriptor::DeserializeRealtimeSupport(), EffectTypeAnalyze, EffectTypeGenerate, EffectTypeHidden, EffectTypeNone, EffectTypeProcess, EffectTypeTool, audacity::BasicSettings::GetChildGroups(), PlatformCompatibility::GetExecutablePath(), 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, audacity::BasicSettings::Read(), REGROOT, PluginDescriptor::SetEffectAutomatable(), PluginDescriptor::SetEffectDefault(), PluginDescriptor::SetEffectFamily(), PluginDescriptor::SetEffectInteractive(), PluginDescriptor::SetEffectType(), PluginDescriptor::SetEnabled(), PluginDescriptor::SetID(), PluginDescriptor::SetImporterExtensions(), PluginDescriptor::SetImporterIdentifier(), PluginDescriptor::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:

◆ NotifyPluginsChanged()

void PluginManager::NotifyPluginsChanged ( )

Definition at line 900 of file PluginManager.cpp.

901{
903}
CallbackReturn Publish(const PluginsChangedMessage &message)
Send a message to connected callbacks.
Definition: Observer.h:207

References Observer::Publisher< PluginsChangedMessage >::Publish().

Referenced by DropFile(), and PluginStartupRegistration::Run().

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

1239{
1240 return wxString::Format(wxT("%s_%s_%s_%s_%s"),
1242 effect->GetFamily().Internal(),
1243 effect->GetVendor().Internal(),
1244 effect->GetSymbol().Internal(),
1245 effect->GetPath());
1246}

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

158{ 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 anonymous_namespace{ExportPCM.cpp}::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 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}
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}
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 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.SetRealtimeSupport(effect->RealtimeSupport());
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 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 995 of file PluginManager.cpp.

997{
998 PluginDescriptor & plug =
999 CreatePlugin(GetID(effect.get()), effect.get(), type);
1000
1001 plug.SetEffectType(effect->GetType());
1002 plug.SetEffectFamily(effect->GetFamily().Internal());
1003 plug.SetEffectInteractive(effect->IsInteractive());
1004 plug.SetEffectDefault(effect->IsDefault());
1005 plug.SetRealtimeSupport(effect->RealtimeSupport());
1006 plug.SetEffectAutomatable(effect->SupportsAutomation());
1007
1008 plug.SetEffectLegacy(true);
1009 plug.SetEnabled(true);
1010 plug.SetValid(true);
1011
1012 mLoadedInterfaces[plug.GetID()] = std::move(effect);
1013
1014 return plug.GetID();
1015}
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 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 Flush() noexcept=0
bool DeleteEntry(const wxString &key)
Deletes specified entry if exists.

References audacity::BasicSettings::DeleteEntry(), audacity::BasicSettings::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}
bool DeleteGroup(const wxString &key)
Deletes specified group if exists.

References audacity::BasicSettings::DeleteGroup(), audacity::BasicSettings::Flush(), GetSettings(), and Group().

Here is the call graph for this function:

◆ Save()

void PluginManager::Save ( )

Save to preferences.

Definition at line 868 of file PluginManager.cpp.

869{
870 // Create/Open the registry
871 auto pRegistry = sFactory(FileNames::PluginRegistry());
872 auto &registry = *pRegistry;
873
874 // Clear pluginregistry.cfg (not audacity.cfg)
875 registry.Clear();
876
877 // Save the individual groups
878 SaveGroup(&registry, PluginTypeEffect);
879 SaveGroup(&registry, PluginTypeExporter);
881 SaveGroup(&registry, PluginTypeImporter);
882 SaveGroup(&registry, PluginTypeStub);
883
884 // Not used by 2.1.1 or greater, but must save to allow users to switch between 2.1.0
885 // and 2.1.1+. This should be removed after a few releases past 2.1.0.
886 //SaveGroup(&registry, PluginTypeNone);
887
888 // And now the providers
889 SaveGroup(&registry, PluginTypeModule);
890
891 // Write the version string
892 registry.Write(REGVERKEY, REGVERCUR);
893
894 // Just to be safe
895 registry.Flush();
896
898}
constexpr auto REGVERCUR
void SaveGroup(audacity::BasicSettings *pRegistry, PluginType type)

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

Referenced by DropFile(), InitializePlugins(), and PluginStartupRegistration::Run().

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

◆ SaveGroup()

void PluginManager::SaveGroup ( audacity::BasicSettings pRegistry,
PluginType  type 
)
private

Definition at line 910 of file PluginManager.cpp.

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

References audacity::BasicSettings::BeginGroup(), 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, audacity::BasicSettings::Write(), 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 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 1421 of file PluginManager.cpp.

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

References audacity::BasicSettings::Flush(), GetSettings(), key, MenuRegistry::Visit(), and audacity::BasicSettings::Write().

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

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

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

References anonymous_namespace{ExportPCM.cpp}::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 1017 of file PluginManager.cpp.

1018{
1019 mRegisteredPlugins.erase(ID);
1020 mLoadedInterfaces.erase(ID);
1021}

References mLoadedInterfaces, and mRegisteredPlugins.

Referenced by EffectManager::UnregisterEffect().

Here is the caller graph for this function:

Member Data Documentation

◆ mCurrentIndex

int PluginManager::mCurrentIndex
private

Definition at line 235 of file PluginManager.h.

◆ mDirty

bool PluginManager::mDirty
private

Definition at line 234 of file PluginManager.h.

◆ mEffectPluginsCleared

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

Definition at line 239 of file PluginManager.h.

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

◆ mInstance

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

Definition at line 228 of file PluginManager.h.

Referenced by Get().

◆ mLoadedInterfaces

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

Definition at line 238 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 241 of file PluginManager.h.

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

◆ mSettings

std::unique_ptr<audacity::BasicSettings> PluginManager::mSettings
private

Definition at line 232 of file PluginManager.h.

Referenced by GetSettings(), and PluginManager().


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