source: trunk/CrypPluginBase/PluginExtension.cs @ 1424

Last change on this file since 1424 was 1424, checked in by saternus, 12 years ago

CT Plugin Loading

File size: 18.4 KB
Line 
1/*
2   Copyright 2008 Martin Saternus, University of Duisburg-Essen
3
4   Licensed under the Apache License, Version 2.0 (the "License");
5   you may not use this file except in compliance with the License.
6   You may obtain a copy of the License at
7
8       http://www.apache.org/licenses/LICENSE-2.0
9
10   Unless required by applicable law or agreed to in writing, software
11   distributed under the License is distributed on an "AS IS" BASIS,
12   WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
13   See the License for the specific language governing permissions and
14   limitations under the License.
15*/
16
17using System;
18using System.Collections.Generic;
19using System.Reflection;
20using System.Windows;
21using System.Windows.Controls;
22using System.Windows.Media.Imaging;
23using System.Windows.Documents;
24using System.Windows.Markup;
25using Cryptool.PluginBase.Miscellaneous;
26using Cryptool.PluginBase.Resources;
27using System.Resources;
28using System.Threading;
29using System.Globalization;
30using System.Collections;
31using Cryptool.PluginBase.Control;
32
33namespace Cryptool.PluginBase
34{
35    public static class PluginExtension
36    {
37        public static readonly string[] Interfaces = new string[] {
38                typeof(Cryptool.PluginBase.Analysis.IDifferential).FullName,
39                typeof(Cryptool.PluginBase.Analysis.IAnalysisMisc).FullName,
40                typeof(Cryptool.PluginBase.Analysis.ISpecific).FullName,
41                typeof(Cryptool.PluginBase.Analysis.IStatistic).FullName,
42                typeof(Cryptool.PluginBase.Cryptography.IEncryption).FullName,
43                typeof(Cryptool.PluginBase.Cryptography.ICheckSumHash).FullName,
44                typeof(Cryptool.PluginBase.Cryptography.ICryptographicHash).FullName,
45                typeof(Cryptool.PluginBase.Cryptography.ICryptographyMisc).FullName,
46                typeof(Cryptool.PluginBase.Editor.IEditor).FullName,
47                typeof(Cryptool.PluginBase.Generator.IKeyGenerator).FullName,
48                typeof(Cryptool.PluginBase.Generator.IGeneratorMisc).FullName,
49                typeof(Cryptool.PluginBase.Generator.IRandomNumberGenerator).FullName,
50                typeof(Cryptool.PluginBase.IO.IInput).FullName,
51                typeof(Cryptool.PluginBase.IO.IIOMisc).FullName,
52                typeof(Cryptool.PluginBase.IO.IOutput).FullName,
53                typeof(Cryptool.PluginBase.IO.IThroughput).FullName,
54                typeof(Cryptool.PluginBase.Tool.ITool).FullName };
55
56        public static event GuiLogNotificationEventHandler OnGuiLogNotificationOccured;
57
58        private static void GuiLogMessage(string message, NotificationLevel logLevel)
59        {
60          EventsHelper.GuiLogMessage(OnGuiLogNotificationOccured, null, new GuiLogEventArgs(message, null, logLevel));
61        }
62
63        /// <summary>
64        /// Gets the properties marked with the PropertyInfoAttribute.
65        /// </summary>
66        /// <param name="plugin">The plugin.</param>
67        /// <returns></returns>
68        public static PropertyInfoAttribute[] GetProperties(this IPlugin plugin)
69        {
70          List<PropertyInfoAttribute> propertyInfos = new List<PropertyInfoAttribute>();
71          foreach (PropertyInfo pInfo in plugin.GetType().GetProperties())
72                {
73                        PropertyInfoAttribute[] attributes = (PropertyInfoAttribute[])pInfo.GetCustomAttributes(typeof(PropertyInfoAttribute), false);
74                if (attributes.Length == 1)
75                {
76                    PropertyInfoAttribute attr  = attributes[0];
77                    attr.PropertyName = pInfo.Name;
78                    attr.PluginType = plugin.GetType();
79                    attr.PropertyInfo = pInfo;
80                    propertyInfos.Add(attr);
81                }
82                }
83          return propertyInfos.ToArray();
84        }
85
86        /// <summary>
87        /// Gets the properties marked with the PropertyInfoAttribute that match given direction.
88        /// </summary>
89        /// <param name="plugin">The plugin.</param>
90        /// <param name="direction">The direction.</param>
91        /// <returns></returns>
92        public static PropertyInfoAttribute[] GetProperties(this IPlugin plugin, Direction direction)
93        {
94          List<PropertyInfoAttribute> list = new List<PropertyInfoAttribute>();
95          foreach (PropertyInfoAttribute pInfo in plugin.GetProperties())
96          {
97            if (pInfo.Direction == direction) list.Add(pInfo);
98          }
99          return list.ToArray();
100        }
101
102        public static EditorSpecificPluginAttribute GetEditorSpecificPluginAttribute(this Type type)
103        {
104          EditorSpecificPluginAttribute[] attributes = (EditorSpecificPluginAttribute[])type.GetCustomAttributes(typeof(EditorSpecificPluginAttribute), false);
105          if (attributes.Length == 1)
106            return attributes[0];
107          return null;
108        }
109
110        public static DynamicPropertyInfoAttribute GetDynamicPropertyInfo(this IPlugin plugin)
111        {
112          foreach (PropertyInfo pInfo in plugin.GetType().GetProperties())
113          {
114            DynamicPropertyInfoAttribute[] attributes = (DynamicPropertyInfoAttribute[])pInfo.GetCustomAttributes(typeof(DynamicPropertyInfoAttribute), false);
115            if (attributes.Length == 1) return attributes[0];
116          }
117          return null;
118        }
119
120        public static Dictionary<string, DynamicProperty> GetDynamicPropertyList(this IPlugin plugin)
121        {
122          foreach (PropertyInfo pInfo in plugin.GetType().GetProperties())
123          {
124            DynamicPropertyInfoAttribute[] attributes = (DynamicPropertyInfoAttribute[])pInfo.GetCustomAttributes(typeof(DynamicPropertyInfoAttribute), false);
125            if (attributes.Length == 1) return pInfo.GetValue(plugin, null) as Dictionary<string, DynamicProperty>;
126          }
127          return null;
128        }
129
130        public static string GetDynamicPropertyName(this IPlugin plugin)
131        {
132          foreach (PropertyInfo pInfo in plugin.GetType().GetProperties())
133          {
134            DynamicPropertyInfoAttribute[] attributes = (DynamicPropertyInfoAttribute[])pInfo.GetCustomAttributes(typeof(DynamicPropertyInfoAttribute), false);
135            if (attributes.Length == 1) return pInfo.Name;
136          }
137          return null;
138        }
139
140        public static EventInfo GetDynamicPropertyEventInfo(this IPlugin plugin)
141        {
142          DynamicPropertyInfoAttribute info = plugin.GetDynamicPropertyInfo();
143          if (info != null)
144          {
145            return plugin.GetType().GetEvent(info.UpdateDynamicPropertiesEvent);
146          }
147          return null;
148        }
149
150        public static EventInfo GetTaskPaneAttributeChanged(this ISettings settings)
151        {
152          foreach (EventInfo eventInfo in settings.GetType().GetEvents())
153          {
154            if (eventInfo.EventHandlerType == typeof(TaskPaneAttributeChangedHandler))
155              return eventInfo;
156          }
157          return null;
158        }
159
160        public static void SetPropertyValue(this IPlugin plugin, PropertyInfo property, object value)
161        {
162            property.SetValue(plugin, value, null);
163        }
164
165        public static object GetPropertyValue(this IPlugin plugin, PropertyInfo property)
166        {
167            return property.GetValue(plugin, null);
168        }
169
170        public static PluginInfoAttribute GetPluginInfoAttribute(this IPlugin plugin)
171        {
172            return GetPluginInfoAttribute(plugin.GetType());
173        }
174
175        public static PluginInfoAttribute GetPluginInfoAttribute(this Type type)
176        {
177            PluginInfoAttribute[] attributes = (PluginInfoAttribute[])type.GetCustomAttributes(typeof(PluginInfoAttribute), false);
178            if (attributes.Length == 1)
179            {
180              // if resource file is set - keys are used instead of values. resource access necessary
181              if (attributes[0].ResourceFile != null)
182              {
183                attributes[0].PluginType = type;
184              }
185              return attributes[0];
186            }
187            return null;
188        }
189
190        public static AuthorAttribute GetPluginAuthorAttribute(this IPlugin plugin)
191        {
192          if (plugin != null)
193            return GetPluginAuthorAttribute(plugin.GetType());
194          return null;
195        }
196
197        public static AuthorAttribute GetPluginAuthorAttribute(this Type type)
198        {
199          if (type == null)
200            return null;
201          AuthorAttribute[] attributes = (AuthorAttribute[])type.GetCustomAttributes(typeof(AuthorAttribute), false);
202          if (attributes.Length == 1)
203            return attributes[0];
204          else
205            return null;
206        }
207
208        public static TaskPaneAttribute[] GetSettingsProperties(this ISettings settings, IPlugin plugin)
209        {
210          return GetSettingsProperties(settings.GetType(), plugin);
211        }
212
213        public static TaskPaneAttribute[] GetSettingsProperties(this Type type, IPlugin plugin)
214        {
215          try
216          {
217            List<TaskPaneAttribute> taskPaneAttributes = new List<TaskPaneAttribute>();
218            foreach (PropertyInfo pInfo in type.GetProperties())
219            {
220              TaskPaneAttribute[] attributes = (TaskPaneAttribute[])pInfo.GetCustomAttributes(typeof(TaskPaneAttribute), false);
221              if (attributes != null && attributes.Length == 1)
222              {
223                TaskPaneAttribute attr = attributes[0];
224                attr.PropertyName = pInfo.Name;
225                // does plugin have a resource file for translation?
226                if (plugin.GetType().GetPluginInfoAttribute().ResourceFile != null)
227                  attr.PluginType = plugin.GetType();
228                taskPaneAttributes.Add(attr);
229              }
230            }
231
232            foreach (MethodInfo mInfo in type.GetMethods())
233            {
234              if (mInfo.IsPublic && mInfo.GetParameters().Length == 0)
235              {
236                TaskPaneAttribute[] attributes = (TaskPaneAttribute[])mInfo.GetCustomAttributes(typeof(TaskPaneAttribute), false);
237                if (attributes != null && attributes.Length == 1)
238                {
239                  TaskPaneAttribute attr = attributes[0];
240                  attr.Method = mInfo;
241                  attr.PropertyName = mInfo.Name;
242                  // does plugin have a resource file for translation?
243                  if (plugin.GetType().GetPluginInfoAttribute().ResourceFile != null)
244                    attr.PluginType = plugin.GetType();
245                  taskPaneAttributes.Add(attr);
246                }
247              }
248            }
249
250            return taskPaneAttributes.ToArray();
251          }
252          catch (Exception ex)
253          {
254            GuiLogMessage(ex.Message, NotificationLevel.Error);
255          }
256          return null;
257        }
258
259        public static RibbonBarAttribute[] GetRibbonBarSettingsProperties(this ISettings settings, IPlugin plugin)
260        {
261          return GetRibbonBarSettingsProperties(settings.GetType(), plugin);
262        }
263
264        public static RibbonBarAttribute[] GetRibbonBarSettingsProperties(this Type type, IPlugin plugin)
265        {
266          try
267          {
268            List<RibbonBarAttribute> taskPaneAttributes = new List<RibbonBarAttribute>();
269            foreach (PropertyInfo pInfo in type.GetProperties())
270            {
271              RibbonBarAttribute[] attributes = (RibbonBarAttribute[])pInfo.GetCustomAttributes(typeof(RibbonBarAttribute), false);
272              if (attributes != null && attributes.Length == 1)
273              {
274                RibbonBarAttribute attr = attributes[0];
275                attr.PropertyName = pInfo.Name;
276                // does plugin have a resource file for translation?
277                if (plugin.GetType().GetPluginInfoAttribute().ResourceFile != null)
278                  attr.PluginType = plugin.GetType();
279                taskPaneAttributes.Add(attr);
280              }
281            }
282
283            foreach (MethodInfo mInfo in type.GetMethods())
284            {
285              if (mInfo.IsPublic && mInfo.GetParameters().Length == 0)
286              {
287                RibbonBarAttribute[] attributes = (RibbonBarAttribute[])mInfo.GetCustomAttributes(typeof(RibbonBarAttribute), false);
288                if (attributes != null && attributes.Length == 1)
289                {
290                  RibbonBarAttribute attr = attributes[0];
291                  attr.Method = mInfo;
292                  attr.PropertyName = mInfo.Name;
293                  // does plugin have a resource file for translation?
294                  if (plugin.GetType().GetPluginInfoAttribute().ResourceFile != null)
295                    attr.PluginType = plugin.GetType();
296                  taskPaneAttributes.Add(attr);
297                }
298              }
299            }
300
301            return taskPaneAttributes.ToArray();
302          }
303          catch (Exception ex)
304          {
305            GuiLogMessage(ex.Message, NotificationLevel.Error);
306          }
307          return null;
308        }
309
310        public static SettingsFormatAttribute GetSettingsFormat(this ISettings settings, string propertyName)
311        {
312          if (settings == null || propertyName == null || propertyName == string.Empty)
313            return null;
314          return GetSettingsFormat(settings.GetType(), propertyName);
315        }
316
317        public static SettingsFormatAttribute GetSettingsFormat(this Type type, string propertyName)
318        {
319          if (type == null || propertyName == null || propertyName == string.Empty)
320            return null;
321          try
322          {
323            if (type.GetProperty(propertyName) != null)
324            {
325              SettingsFormatAttribute[] settingsFormat = (SettingsFormatAttribute[])type.GetProperty(propertyName).GetCustomAttributes(typeof(SettingsFormatAttribute), false);
326              if (settingsFormat != null && settingsFormat.Length == 1)
327                return settingsFormat[0];
328            }
329          }
330          catch (Exception ex)
331          {
332            GuiLogMessage(ex.Message, NotificationLevel.Error);
333          }
334          return null;
335        }   
336
337        public static Image GetImage(this IPlugin plugin, int index)
338        {
339            return GetImage(plugin.GetType(), index);
340        }
341
342        public static Image GetImage(this Type type, int index)
343        {
344          try
345          {
346            return GetImageWithoutLogMessage(type, index);
347          }
348          catch (Exception exception)
349          {
350            if (type != null)
351              GuiLogMessage(string.Format(Resource.plugin_extension_error_get_image, new object[] { type.Name, exception.Message }), NotificationLevel.Error);
352            else
353              GuiLogMessage(exception.Message, NotificationLevel.Error);
354            return null;
355          }
356        }
357
358        public static Image GetImageWithoutLogMessage(this Type type, int index)
359        {
360          string icon = type.GetPluginInfoAttribute().Icons[index];
361          int sIndex = icon.IndexOf('/');
362          Image img = new Image();
363          img.Source = BitmapFrame.Create(new Uri(string.Format("pack://application:,,,/{0};component/{1}", icon.Substring(0, sIndex), icon.Substring(sIndex + 1))));
364          return img;
365        }
366
367        public static string GetPluginStringResource(this IPlugin plugin, string keyword)
368        {
369          try
370          {
371            return plugin.GetType().GetPluginStringResource(keyword);
372          }
373          catch (Exception exception)
374          {
375            GuiLogMessage(exception.Message, NotificationLevel.Error);
376            return null;
377          }
378        }
379
380        public static string GetPluginStringResource(this Type type, string keyword)
381        {
382          try
383          {
384            // Get resource file from plugin assembly -> <Namespace>.<ResourceFileName> without "resx" file extension
385            ResourceManager resman = new ResourceManager(type.GetPluginInfoAttribute().ResourceFile, type.Assembly);
386
387            string[] resources = type.Assembly.GetManifestResourceNames();
388            // string test = resman.GetString("toolTip", new CultureInfo("de-DE"));
389
390            // Load the translation for the keyword
391            string translation = resman.GetString(keyword);
392            if (translation != null)
393              return translation;
394            else
395              return keyword;
396          }
397          catch (Exception exception)
398          {
399            GuiLogMessage(exception.Message, NotificationLevel.Error);
400            return keyword;
401          }
402        }       
403
404        public static FlowDocument GetDescriptionDocument(this IPlugin plugin)
405        {
406          try
407          {
408            string description = plugin.GetPluginInfoAttribute().DescriptionUrl;
409            if (description != null && description != string.Empty && description != "")
410            {
411              int sIndex = description.IndexOf('/');
412              if (sIndex == -1) return null;
413              XamlReader xaml = new XamlReader();
414              return (FlowDocument)xaml.LoadAsync(Application.GetResourceStream(new Uri(string.Format("pack://application:,,,/{0};component/{1}", description.Substring(0, sIndex), description.Substring(sIndex + 1)))).Stream);
415            }
416            return null;
417          }
418          catch (Exception exception)
419          {
420            if (plugin != null)
421              GuiLogMessage(string.Format(Resource.plugin_extension_error_get_description, new object[] { plugin.GetType().Name, exception.Message }), NotificationLevel.Error);
422            else
423              GuiLogMessage(exception.Message, NotificationLevel.Error);
424            return null; 
425          }
426        }
427
428        public static IPlugin CreateObject(this Type type)
429        {
430          if (type.GetInterface(typeof(IPlugin).Name) != null)
431          {
432            try
433            {
434              return (IPlugin)Activator.CreateInstance(type);             
435            }
436            catch (Exception exception)
437            {
438              if (type != null)
439                GuiLogMessage(string.Format(Resource.plugin_extension_error_get_description, new object[] { type.Name, exception.Message }), NotificationLevel.Error);
440              else
441                GuiLogMessage(exception.Message, NotificationLevel.Error);
442              return null;
443            }
444          }
445          return null;
446        }
447    }
448}
Note: See TracBrowser for help on using the repository browser.