Audacity 3.2.0
PluginManager.h
Go to the documentation of this file.
1/**********************************************************************
2
3 Audacity: A Digital Audio Editor
4
5 PluginManager.h
6
7 Leland Lucius
8
9**********************************************************************/
10
11#ifndef __AUDACITY_PLUGINMANAGER_H__
12#define __AUDACITY_PLUGINMANAGER_H__
13
14#include <wx/defs.h>
15
16#include "wxArrayStringEx.h"
17#include <functional>
18#include <map>
19#include <memory>
20#include <vector>
21
22#include "EffectInterface.h"
23#include "PluginInterface.h"
24#include "PluginDescriptor.h"
25#include "Observer.h"
26
27class wxArrayString;
28class FileConfig;
29
31//
32// PluginManager
33//
35
36typedef std::map<PluginID, PluginDescriptor> PluginMap;
37
38typedef wxArrayString PluginIDs;
39
41
43
44class MODULE_MANAGER_API PluginManager final
46 , public Observer::Publisher<PluginsChangedMessage>
47{
48public:
49
50 RegistryPath GetPluginEnabledSetting( const PluginID &ID ) const;
51 RegistryPath GetPluginEnabledSetting( const PluginDescriptor &desc ) const;
52
53 // PluginManagerInterface implementation
54
56 const PluginPath &path, const TranslatableString *pSymbol) override;
57
58 bool IsPluginLoaded(const wxString& ID) const;
59
61 const PluginID & RegisterPlugin(PluginProvider *provider) override;
62 const PluginID & RegisterPlugin(PluginProvider *provider, ComponentInterface *command);
63 const PluginID & RegisterPlugin(PluginProvider *provider, EffectDefinitionInterface *effect, int type) override;
64
65 void FindFilesInPathList(const wxString & pattern,
66 const FilePaths & pathList,
67 FilePaths & files,
68 bool directories = false) override;
69
70 bool HasConfigGroup(ConfigurationType type, const PluginID & ID,
71 const RegistryPath & group) /* not override */;
72 bool GetConfigSubgroups(ConfigurationType type, const PluginID & ID,
73 const RegistryPath & group,
74 RegistryPaths & subgroups) override;
75
76 bool HasConfigValue(ConfigurationType type, const PluginID & ID,
77 const RegistryPath & group, const RegistryPath & key) override;
78
79 bool GetConfigValue(ConfigurationType type, const PluginID & ID,
80 const RegistryPath & group, const RegistryPath & key,
81 ConfigReference var, ConfigConstReference defval) override;
82
83 bool SetConfigValue(ConfigurationType type, const PluginID & ID,
84 const RegistryPath & group, const RegistryPath & key,
85 ConfigConstReference value) override;
86
88 const PluginID & ID, const RegistryPath & group) override;
89 bool RemoveConfig(ConfigurationType type, const PluginID & ID,
90 const RegistryPath & group, const RegistryPath & key) override;
91
92 // PluginManager implementation
93
94 // Initialization must inject a factory to make a concrete subtype of
95 // FileConfig
96 using FileConfigFactory = std::function<
97 std::unique_ptr<FileConfig>(const FilePath &localFilename ) >;
100 void Terminate();
101
102 bool DropFile(const wxString &fileName);
103
104 static PluginManager & Get();
105
106 static PluginID GetID(PluginProvider *provider);
107 static PluginID GetID(ComponentInterface *command);
108 static PluginID OldGetID(const EffectDefinitionInterface* effect);
109 static PluginID GetID(const EffectDefinitionInterface* effect);
112 static Identifier GetEffectNameFromID(const PluginID &ID);
113
114 // This string persists in configuration files
115 // So config compatibility will break if it is changed across Audacity versions
116 static wxString GetPluginTypeString(PluginType type);
117
118 static bool IsPluginAvailable(const PluginDescriptor& plug);
119
120 int GetPluginCount(PluginType type);
121 const PluginDescriptor *GetPlugin(const PluginID & ID) const;
122
125 class MODULE_MANAGER_API Iterator {
126 public:
128 explicit Iterator(PluginManager &manager);
131 int pluginType
132 );
135 bool operator != (int) const {
136 return mIterator != mPm.mRegisteredPlugins.end();
137 }
138 Iterator &operator ++ ();
139 auto &operator *() const { return mIterator->second; }
140 private:
141 void Advance(bool incrementing);
143 PluginMap::iterator mIterator;
145 int mPluginType{ PluginTypeNone };
146 };
147 struct Range {
149 Iterator begin() const { return first; }
150 int end() const { return 0; }
151 };
152
153 Range AllPlugins() { return { Iterator{ *this } }; }
154 Range PluginsOfType(int type) { return { Iterator{ *this, type } }; }
155 Range EffectsOfType(EffectType type) { return { Iterator{ *this, type } }; }
157
158 bool IsPluginEnabled(const PluginID & ID);
159 void EnablePlugin(const PluginID & ID, bool enable);
160
161 const ComponentInterfaceSymbol & GetSymbol(const PluginID & ID);
162 ComponentInterface *Load(const PluginID & ID);
163
164 void ClearEffectPlugins();
165
171 std::map<wxString, std::vector<wxString>> CheckPluginUpdates();
172
174 const PluginID & RegisterPlugin(
175 std::unique_ptr<EffectDefinitionInterface> effect, PluginType type );
176 void UnregisterPlugin(const PluginID & ID);
177
179 void Load();
181 void Save();
182
183 void NotifyPluginsChanged();
184
187 const PluginRegistryVersion &GetRegistryVersion() const override;
188
189private:
190 // private! Use Get()
193
194 void InitializePlugins();
195
196 void LoadGroup(FileConfig *pRegistry, PluginType type);
197 void SaveGroup(FileConfig *pRegistry, PluginType type);
198
199 PluginDescriptor & CreatePlugin(const PluginID & id, ComponentInterface *ident, PluginType type);
200
202
203 bool HasGroup(const RegistryPath & group);
204 bool GetSubgroups(const RegistryPath & group, RegistryPaths & subgroups);
205
206 bool HasConfigValue(const RegistryPath & key);
208 ConfigConstReference defval);
210
211 /* Return values are keys for lookup in a config file */
212 RegistryPath SettingsPath(ConfigurationType type, const PluginID & ID);
213 RegistryPath Group(ConfigurationType type, const PluginID & ID,
214 const RegistryPath & group);
215 RegistryPath Key(ConfigurationType type, const PluginID & ID,
216 const RegistryPath & group, const RegistryPath & key);
217
218 // The PluginID must be kept unique. Since the wxFileConfig class does not preserve
219 // case, we use base64 encoding.
220 wxString ConvertID(const PluginID & ID);
221
222private:
223 friend std::default_delete<PluginManager>;
224 static std::unique_ptr<PluginManager> mInstance;
225
226 bool IsDirty();
227 void SetDirty(bool dirty = true);
228 std::unique_ptr<FileConfig> mSettings;
229
230 bool mDirty;
232
234 std::map<PluginID, std::unique_ptr<ComponentInterface>> mLoadedInterfaces;
235 std::vector<PluginDescriptor> mEffectPluginsCleared;
236
238};
239
240// Defining these special names in the low-level PluginManager.h
241// is unfortunate
242// Internal name should be stable across versions
243#define NYQUIST_PROMPT_ID wxT("Nyquist Prompt")
244// User-visible name might change in later versions
245#define NYQUIST_PROMPT_NAME XO("Nyquist Prompt")
246
247// Latest version of the plugin registry config
248constexpr auto REGVERCUR = "1.3";
249
250#endif /* __AUDACITY_PLUGINMANAGER_H__ */
static const AudacityProject::AttachedObjects::RegisteredFactory key
EffectType
@ EffectTypeNone
wxString PluginID
Definition: EffectManager.h:30
static PluginID GetID(EffectPlugin &effect)
Definition: EffectUI.cpp:34
const TranslatableString desc
Definition: ExportPCM.cpp:55
wxString RegistryPath
Definition: Identifier.h:218
wxString PluginPath
type alias for identifying a Plugin supplied by a module, each module defining its own interpretation...
Definition: Identifier.h:214
std::vector< RegistryPath > RegistryPaths
Definition: Identifier.h:219
LV2EffectSettings & GetSettings(EffectSettings &settings)
Definition: LV2Ports.h:215
Vector operator*(const Vector &left, const Vector &right)
Definition: Matrix.cpp:153
static CommandHandlerObject & ident(AudacityProject &project)
PluginType
@ PluginTypeNone
wxString PluginRegistryVersion
Type of plugin registry version information.
constexpr auto REGVERCUR
wxArrayString PluginIDs
Definition: PluginManager.h:38
std::map< PluginID, PluginDescriptor > PluginMap
Definition: PluginManager.h:28
wxString FilePath
Definition: Project.h:21
static const AttachedProjectObjects::RegisteredFactory manager
bool operator!=(const WaveTrackLocation &a, const WaveTrackLocation &b)
ComponentInterface provides name / vendor / version functions to identify plugins....
ComponentInterfaceSymbol pairs a persistent string identifier used internally with an optional,...
EffectDefinitionInterface is a ComponentInterface that adds some basic read-only information about ef...
An explicitly nonlocalized string, not meant for the user to see.
Definition: Identifier.h:22
An object that sends messages to an open-ended list of subscribed callbacks.
Definition: Observer.h:108
const PluginManager & mPm
PluginMap::iterator mIterator
PluginManager maintains a list of all plug ins. That covers modules, effects, generators,...
Definition: PluginManager.h:47
Range EffectsOfType(EffectType type)
std::function< std::unique_ptr< FileConfig >(const FilePath &localFilename) > FileConfigFactory
Definition: PluginManager.h:97
std::vector< PluginDescriptor > mEffectPluginsCleared
PluginRegistryVersion mRegver
Range PluginsOfType(int type)
static std::unique_ptr< PluginManager > mInstance
std::unique_ptr< FileConfig > mSettings
PluginMap mRegisteredPlugins
void SetDirty(bool dirty=true)
std::map< PluginID, std::unique_ptr< ComponentInterface > > mLoadedInterfaces
Range AllPlugins()
virtual bool RemoveConfigSubgroup(ConfigurationType type, const PluginID &ID, const RegistryPath &group)=0
virtual bool GetConfigValue(ConfigurationType type, const PluginID &ID, const RegistryPath &group, const RegistryPath &key, ConfigReference var, ConfigConstReference defval)=0
virtual bool RemoveConfig(ConfigurationType type, const PluginID &ID, const RegistryPath &group, const RegistryPath &key)=0
virtual bool GetConfigSubgroups(ConfigurationType type, const PluginID &ID, const RegistryPath &group, RegistryPaths &subgroups)=0
PluginSettings::ConfigReference ConfigReference
virtual bool SetConfigValue(ConfigurationType type, const PluginID &ID, const RegistryPath &group, const RegistryPath &key, ConfigConstReference value)=0
virtual void FindFilesInPathList(const wxString &pattern, const FilePaths &pathList, FilePaths &files, bool directories=false)=0
virtual const PluginID & RegisterPlugin(PluginProvider *provider)=0
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)?
PluginSettings::ConfigConstReference ConfigConstReference
virtual bool HasConfigValue(ConfigurationType type, const PluginID &ID, const RegistryPath &group, const RegistryPath &key)=0
virtual const PluginRegistryVersion & GetRegistryVersion() const =0
What is the plugin registry version number now in the file?
Holds a msgid for the translation catalog; may also bind format arguments.
Extend wxArrayString with move operations and construction and insertion fromstd::initializer_list.
Services * Get()
Fetch the global instance, or nullptr if none is yet installed.
Definition: BasicUI.cpp:196
ConfigReferenceGenerator< false, ConfigValueTypes >::type ConfigReference
ConfigReferenceGenerator< true, ConfigValueTypes >::type ConfigConstReference
bool HasConfigGroup(const EffectDefinitionInterface &ident, PluginSettings::ConfigurationType type, const RegistryPath &group)
THEME_RESOURCES_API void Load()
static RegisteredToolbarFactory factory
Iterator begin() const