← Back to branch summary

~ubuntu-branches/debian/sid/docky/sid

« back to all changes in this revision

Viewing changes to Docky/Docky/PluginManager.cs

  • Committer: Package Import Robot
  • Author(s): Rico Tzschichholz
  • Date: 2012-01-19 19:03:38 UTC
  • mfrom: (1.1.14) (10.1.9 experimental)
  • Revision ID: package-import@ubuntu.com-20120119190338-n44q7tmqsrkudvk7
Tags: 2.1.3-2
* Upload to unstable
* debian/watch:
  + Look for xz tarballs from now on

Show diffs side-by-side

added added

removed removed

Lines of Context:
Docky/Docky/PluginManager.cs
17
17
 
18
18
using System;
19
19
using System.IO;
 
20
using System.Xml;
20
21
using System.Linq;
 
22
using System.Reflection;
21
23
using System.Collections.Generic;
22
 
using System.Collections.ObjectModel;
23
24
 
24
25
using Mono.Addins;
25
 
//using Mono.Addins.Gui;
26
 
//using Mono.Addins.Setup;
27
26
 
28
27
using Docky.Items;
29
28
using Docky.Services;
45
44
        
46
45
        public class PluginManager
47
46
        {
48
 
                public static readonly string DefaultPluginIcon = "package";
 
47
                /// <summary>
 
48
                /// The default icon for addins that don't supply one.
 
49
                /// </summary>
 
50
                public static string DefaultPluginIcon {
 
51
                        get {
 
52
                                return "package";
 
53
                        }
 
54
                }
49
55
                
50
 
                const string PluginsDirectory = "plugins";
51
 
                const string ApplicationDirectory = "docky";
52
 
                const string DefaultAddinsDirectory = "addins";
 
56
                public static Dictionary<Addin, Dictionary<string, string>> AddinMetadata { get; private set; }
53
57
                
54
58
                const string IPExtensionPath = "/Docky/ItemProvider";
55
59
                const string ConfigExtensionPath = "/Docky/Configuration";
59
63
                //// <value>
60
64
                /// Directory where Docky saves its Mono.Addins repository cache.
61
65
                /// </value>
62
 
                public static string UserPluginsDirectory {
63
 
                        get {
64
 
                                string userData = Environment.GetFolderPath (Environment.SpecialFolder.LocalApplicationData);
65
 
                                return Path.Combine (Path.Combine (userData, ApplicationDirectory), PluginsDirectory);
66
 
                        }
 
66
                public static GLib.File UserPluginsDirectory {
 
67
                        get { return DockServices.Paths.UserDataFolder.GetChild ("plugins"); }
67
68
                }
68
69
                
69
 
                public static string UserAddinInstallationDirectory {
70
 
                        get { return Path.Combine (UserPluginsDirectory, DefaultAddinsDirectory); }
 
70
                /// <summary>
 
71
                /// Directory where Docky saves Addin files.
 
72
                /// </summary>
 
73
                public static GLib.File UserAddinInstallationDirectory {
 
74
                        get { return UserPluginsDirectory.GetChild ("addins"); }
71
75
                }
72
 
                        
 
76
 
73
77
                /// <summary>
74
78
                /// Performs plugin system initialization. Should be called before this
75
79
                /// class or any Mono.Addins class is used. The ordering is very delicate.
78
82
                {
79
83
                        // Initialize Mono.Addins.
80
84
                        try {
81
 
                                AddinManager.Initialize (UserPluginsDirectory);
 
85
                                AddinManager.Initialize (UserPluginsDirectory.Path);
82
86
                        } catch (InvalidOperationException e) {
83
87
                                Log<PluginManager>.Error ("AddinManager.Initialize: {0}", e.Message);
84
88
                                Log<PluginManager>.Warn ("Rebuild Addin.Registry and reinitialize AddinManager");
85
89
                                AddinManager.Registry.Rebuild (null);
86
90
                                AddinManager.Shutdown ();
87
 
                                AddinManager.Initialize (UserPluginsDirectory);
 
91
                                AddinManager.Initialize (UserPluginsDirectory.Path);
88
92
                        }
89
93
 
90
94
                        AddinManager.Registry.Update (null);
91
95
                        
 
96
                        // parse the addin config files for extended metadata
 
97
                        AddinMetadata = new Dictionary<Addin, Dictionary<string, string>> ();
 
98
                        DockServices.System.RunOnThread (() => {
 
99
                                AllAddins.ToList ().ForEach (a => ParseAddinConfig (a)); 
 
100
                        });
 
101
                        
92
102
                        // Add feedback when addin is loaded or unloaded
93
103
                        AddinManager.AddinLoaded += AddinManagerAddinLoaded;
94
104
                        AddinManager.AddinUnloaded += AddinManagerAddinUnloaded;
96
106
                        Log<PluginManager>.Debug ("Plugin manager initialized.");
97
107
                }
98
108
                
 
109
                /// <summary>
 
110
                /// Shut down the Addin Manager.
 
111
                /// </summary>
99
112
                public static void Shutdown ()
100
113
                {
101
114
                        AddinManager.Shutdown ();
121
134
                        Log<PluginManager>.Info ("Unloaded \"{0}\".", addin.Name);
122
135
                }
123
136
                
 
137
                /// <summary>
 
138
                /// Look up an addin by supplying the Addin ID.
 
139
                /// </summary>
 
140
                /// <param name="id">
 
141
                /// A <see cref="System.String"/>
 
142
                /// </param>
 
143
                /// <returns>
 
144
                /// A <see cref="Addin"/>
 
145
                /// </returns>
124
146
                public static Addin AddinFromID (string id)
125
147
                {
126
148
                        return AddinManager.Registry.GetAddin (id);
127
149
                }
128
150
                
 
151
                /// <summary>
 
152
                /// Enable the addin by supplying the Addin ID.
 
153
                /// </summary>
 
154
                /// <param name="addin">
 
155
                /// A <see cref="Addin"/>
 
156
                /// </param>
 
157
                /// <returns>
 
158
                /// A <see cref="AbstractDockItemProvider"/>
 
159
                /// </returns>
129
160
                public static AbstractDockItemProvider Enable (Addin addin)
130
161
                {
131
162
                        addin.Enabled = true;
132
163
                        return ItemProviderFromAddin (addin.Id);
133
164
                }
134
165
                
 
166
                /// <summary>
 
167
                /// Enable the addin by supplying the <see cref="AbstractDockItemProvider"/>.
 
168
                /// </summary>
 
169
                /// <param name="id">
 
170
                /// A <see cref="System.String"/>
 
171
                /// </param>
 
172
                /// <returns>
 
173
                /// A <see cref="AbstractDockItemProvider"/>
 
174
                /// </returns>
135
175
                public static AbstractDockItemProvider Enable (string id)
136
176
                {
137
177
                        return Enable (AddinFromID (id));
138
178
                }
139
179
                
 
180
                /// <summary>
 
181
                /// Disable the Addin by supplying the <see cref="Addin"/>.
 
182
                /// </summary>
 
183
                /// <param name="addin">
 
184
                /// A <see cref="Addin"/>
 
185
                /// </param>
140
186
                public static void Disable (Addin addin)
141
187
                {
142
188
                        addin.Enabled = false;
143
189
                }
144
190
                
 
191
                /// <summary>
 
192
                /// Disable the addin by supplying the Addin ID.
 
193
                /// </summary>
 
194
                /// <param name="id">
 
195
                /// A <see cref="System.String"/>
 
196
                /// </param>
145
197
                public static void Disable (string id)
146
198
                {
147
199
                        Disable (AddinFromID (id));
148
200
                }
149
201
                
 
202
                /// <summary>
 
203
                /// Disable an addin by supplying the <see cref="AbstractDockItemProvider"/>.
 
204
                /// </summary>
 
205
                /// <param name="provider">
 
206
                /// A <see cref="AbstractDockItemProvider"/>
 
207
                /// </param>
150
208
                public static void Disable (AbstractDockItemProvider provider)
151
209
                {
152
210
                        Disable (AddinIDFromProvider (provider));
153
211
                }
154
212
                
 
213
                /// <summary>
 
214
                /// All addins in the Addins registry.
 
215
                /// </summary>
155
216
                public static IEnumerable<Addin> AllAddins {
156
217
                        get {
157
218
                                return AddinManager.Registry.GetAddins ();
158
219
                        }
159
220
                }
160
 
                
 
221
                /// <summary>
 
222
                /// Installs all addins from the user addin directory.
 
223
                /// </summary>
161
224
                public static void InstallLocalPlugins ()
162
225
                {       
163
226
                        IEnumerable<string> manual;
164
227
                        
165
 
                        manual = Directory.GetFiles (UserAddinInstallationDirectory, "*.dll")
166
 
                                .Select (s => Path.GetFileName (s));
 
228
                        manual = UserAddinInstallationDirectory.GetFiles ("*.dll").Select (f => f.Basename);
167
229
                                        
168
230
                        manual.ToList ().ForEach (dll => Log<PluginManager>.Info ("Installing {0}", dll));
169
231
                        
183
245
                        return null;
184
246
                }
185
247
                
 
248
                /// <summary>
 
249
                /// Returns the <see cref="AbstractDockItemProvider"/> from the supplied Addin ID.
 
250
                /// </summary>
 
251
                /// <param name="addinID">
 
252
                /// A <see cref="System.String"/>
 
253
                /// </param>
 
254
                /// <returns>
 
255
                /// A <see cref="AbstractDockItemProvider"/>
 
256
                /// </returns>
186
257
                public static AbstractDockItemProvider ItemProviderFromAddin (string addinID)
187
258
                {
188
259
                        return ObjectFromAddin<AbstractDockItemProvider> (IPExtensionPath, addinID);
189
260
                }
190
261
 
 
262
                /// <summary>
 
263
                /// Returns the <see cref="ConfigDialog"/> from the supplied Addin ID.
 
264
                /// </summary>
 
265
                /// <param name="addinID">
 
266
                /// A <see cref="System.String"/>
 
267
                /// </param>
 
268
                /// <returns>
 
269
                /// A <see cref="ConfigDialog"/>
 
270
                /// </returns>
191
271
                public static ConfigDialog ConfigForAddin (string addinID)
192
272
                {
193
273
                        return  ObjectFromAddin<ConfigDialog> (ConfigExtensionPath, addinID);
194
274
                }
195
275
                
 
276
                /// <summary>
 
277
                /// Returns the Addin ID from an <see cref="AbstractDockItemProvider"/>.
 
278
                /// </summary>
 
279
                /// <param name="provider">
 
280
                /// A <see cref="AbstractDockItemProvider"/>
 
281
                /// </param>
 
282
                /// <returns>
 
283
                /// A <see cref="System.String"/>
 
284
                /// </returns>
196
285
                public static string AddinIDFromProvider (AbstractDockItemProvider provider)
197
286
                {
198
287
                        foreach (TypeExtensionNode node in AddinManager.GetExtensionNodes (IPExtensionPath)) {
216
305
                /// All loaded ItemProviders.
217
306
                /// </value>
218
307
                public static IEnumerable<AbstractDockItemProvider> ItemProviders {
219
 
                        get { return AddinManager.GetExtensionObjects (IPExtensionPath).OfType<AbstractDockItemProvider> (); }
 
308
                        get { 
 
309
                                return AddinManager.GetExtensionObjects (IPExtensionPath).OfType<AbstractDockItemProvider> ();
 
310
                        }
220
311
                }
221
312
                
222
 
                // this will return a list of Provider IDs that are currently not used by any docks
 
313
                /// <summary>
 
314
                /// A list of Provider IDs that are currently not used by any docks
 
315
                /// </summary> 
223
316
                public static IEnumerable<string> AvailableProviderIDs {
224
317
                        get {
225
 
                                return AllAddins .Where (a => !a.Enabled).Select (a => Addin.GetIdName (a.Id));
 
318
                                return AllAddins.Where (a => !a.Enabled).Select (a => Addin.GetIdName (a.Id));
 
319
                        }
 
320
                }
 
321
                
 
322
                static void ParseAddinConfig (Addin addin)
 
323
                {
 
324
                        Log<PluginManager>.Debug ("Processing config file for \"{0}\".", addin.Name);
 
325
                        Assembly addinAssembly = Assembly.LoadFile (addin.AddinFile);
 
326
                        
 
327
                        string addinManifestName = addinAssembly.GetManifestResourceNames ().FirstOrDefault (res => res.Contains ("addin.xml"));
 
328
                        
 
329
                        if (string.IsNullOrEmpty (addinManifestName)) {
 
330
                                Log<PluginManager>.Warn ("Could not find addin manifest for '{0}'.", addin.AddinFile);
 
331
                                return;
 
332
                        }
 
333
                        
 
334
                        using (Stream s = addinAssembly.GetManifestResourceStream (addinManifestName)) {
 
335
                                XmlDocument addinManifest = new XmlDocument ();
 
336
                                addinManifest.Load (s);
 
337
                                
 
338
                                if (!AddinMetadata.ContainsKey (addin))
 
339
                                        AddinMetadata[addin] = new Dictionary<string, string> ();
 
340
                                
 
341
                                foreach (XmlAttribute a in addinManifest.SelectSingleNode ("/Addin").Attributes)
 
342
                                        AddinMetadata [addin] [a.Name] = a.Value;       
 
343
                        }
 
344
                        
 
345
                        AddinMetadata [addin] ["AssemblyFullName"] = addinAssembly.FullName;
 
346
                        
 
347
                        if (AddinMetadata [addin].ContainsKey ("icon") && AddinMetadata [addin] ["icon"].EndsWith ("@")) {
 
348
                                AddinMetadata [addin] ["icon"] = string.Format ("{0}{1}", AddinMetadata [addin] ["icon"], addinAssembly.FullName);
226
349
                        }
227
350
                }
228
351
        }