RomCheater.PluginFramework/Core/PluginLoader.cs

#region Logging Defines
// include this any class or method that required logging, and comment-out what is not needed

#region Enabled logging levels
#define LOGGING_ENABLE_INFO
#define LOGGING_ENABLE_WARN
#define LOGGING_ENABLE_DEBUG
#define LOGGING_ENABLE_VERBOSEDEBUG
#define LOGGING_ENABLE_ERROR
#define LOGGING_ENABLE_VERBOSEERROR
#define LOGGING_ENABLE_PROFILER
#endregion
#endregion
using System;
using System.Collections.Generic;
using System.Linq;
using System.Text;
using RomCheater.Logging;
using System.IO;
using System.Reflection;
using RomCheater.Core;
using System.Runtime.Serialization;
using System.Security;
using Enterprise.Logging;

namespace RomCheater.PluginFramework.Core
{
    #region plugin loader execeptions
    public class PluginNotFoundException : System.Exception
    {
        public PluginNotFoundException() : base() { }
        public PluginNotFoundException(string message) : base(message) { }
        public PluginNotFoundException(string message, Exception innerException) : base(message, innerException) { }
        [SecuritySafeCritical]
        protected PluginNotFoundException(SerializationInfo info, StreamingContext context) : base(info, context) { }
    }
    public class InvalidPluginException : System.Exception
    {
        public InvalidPluginException() : base() { }
        public InvalidPluginException(string message) : base(message) { }
        public InvalidPluginException(string message, Exception innerException) : base(message, innerException) { }
        [SecuritySafeCritical]
        protected InvalidPluginException(SerializationInfo info, StreamingContext context) : base(info, context) { }
    }
    public class InvalidPluginTypeException : System.Exception
    {
        public InvalidPluginTypeException() : base() { }
        public InvalidPluginTypeException(string message) : base(message) { }
        public InvalidPluginTypeException(string message, Exception innerException) : base(message, innerException) { }
        [SecuritySafeCritical]
        protected InvalidPluginTypeException(SerializationInfo info, StreamingContext context) : base(info, context) { }
    }
    #endregion

    public class PluginLoader : IPluginLoader
    {

        public PluginLoader()
        {
            LoadedConfigPlugins = new List<IConfigPlugin>();
            LoadedInputPlugins = new List<IInputPlugin>();
            LoadedWindowPlugins = new List<IWindowPlugin>();
            LoadedUserControlPlugins = new List<IUserControlPlugin>();
        }
        #region IPluginLoader Members

        public T GetPluginByName<T>(string name) where T : IPluginBase
        {
            T plugin = default(T);
            if (string.IsNullOrEmpty(name))
            {
                throw new ArgumentException("name cannot be null or an empty string", "name");
            }

            bool known = IsKnownPluginName<T>(name, out plugin);
            if (known)
            {
                if (plugin != null)
                {
                    return plugin;
                }
                else
                {
                    throw new InvalidPluginException(string.Format("Plugin name: '{0}' is known, but the returned plugin was null", name));
                }
            }
            else
            {
                if (LoadedConfigPlugins.Count > 0)
                {
                    foreach (var p in LoadedConfigPlugins)
                    {
                        if (p.Name.ToLower() == name.ToLower())
                        {
                            plugin = (T)p;
                            known = true;
                            break;
                        }
                    }
                }
                if (LoadedInputPlugins.Count > 0)
                {
                    foreach (var p in LoadedInputPlugins)
                    {
                        if (p.Name.ToLower() == name.ToLower())
                        {
                            plugin = (T)p;
                            known = true;
                            break;
                        }
                    }
                }
                if (LoadedWindowPlugins.Count > 0)
                {
                    foreach (var p in LoadedWindowPlugins)
                    {
                        if (p.Name.ToLower() == name.ToLower())
                        {
                            plugin = (T)p;
                            known = true;
                            break;
                        }
                    }
                }
                if (LoadedUserControlPlugins.Count > 0)
                {
                    foreach (var p in LoadedUserControlPlugins)
                    {
                        if (p.Name.ToLower() == name.ToLower())
                        {
                            plugin = (T)p;
                            known = true;
                            break;
                        }
                    }
                }
                if (known)
                {
                    return plugin;
                }
                else
                {
                    throw new PluginNotFoundException(string.Format("Could not find a plugin with name: '{0}'", name));
                }
            }
        }
        public T GetPluginByGuid<T>(string plugin_guid) where T : IPluginBase
        {
            T plugin = default(T);

            if (string.IsNullOrEmpty(plugin_guid))
            {
                throw new ArgumentException("plugin_plugin cannot be null or an empty string", "plugin_guid");
            }

            bool known = IsKnownPluginGuid<T>(plugin_guid, out plugin);
            if (known)
            {
                if (plugin != null)
                {
                    return plugin;
                }
                else
                {
                    throw new InvalidPluginException(string.Format("Plugin guid: '{0}' is known, but the returned plugin was null", plugin_guid));
                }
            }
            else
            {                
                if (LoadedConfigPlugins.Count > 0)
                {
                    foreach (var p in LoadedConfigPlugins)
                    {
                        if (p.ID == new Guid(plugin_guid))
                        {
                            plugin = (T)p;
                            known = true;
                            break;
                        }
                    }
                }
                if (LoadedInputPlugins.Count > 0)
                {
                    foreach (var p in LoadedInputPlugins)
                    {
                        if (p.ID == new Guid(plugin_guid))
                        {
                            plugin = (T)p;
                            known = true;
                            break;
                        }
                    }
                }
                if (LoadedWindowPlugins.Count > 0)
                {
                    foreach (var p in LoadedWindowPlugins)
                    {
                        if (p.ID == new Guid(plugin_guid))
                        {
                            plugin = (T)p;
                            known = true;
                            break;
                        }
                    }
                }
                if (LoadedUserControlPlugins.Count > 0)
                {
                    foreach (var p in LoadedUserControlPlugins)
                    {
                        if (p.ID == new Guid(plugin_guid))
                        {
                            plugin = (T)p;
                            known = true;
                            break;
                        }
                    }
                }
            }
            if (known)
            {
                return plugin;
            }
            else
            {
                throw new PluginNotFoundException(string.Format("Could not find a plugin with guid: '{0}'", plugin_guid));
            }
        }
        public string[] GetKnownPluginGuids<T>() where T : IPluginBase
        {
            Type t = typeof(T);
            string name = t.Name.ToLower();

            List<string> guids = new List<string>();
            guids.Add(new Guid().ToString().ToLower()); // add null guids
            switch (name)
            {
                case "iconfigplugin":
                    guids.Add(new Guid("478e225b-c3e8-9280-57ca-384b884fc4cc").ToString().ToLower()); // generic config
                    break;
                case "iinputplugin": 
                    // no known plugins (other than null at this time)
                    break;
                case "iwindowplugin":
                    // no known plugins (other than null at this time)
                    break;
                case "iusercontrolplugin":
                    guids.RemoveAt(0); // userplugins should not have a null plugin guid
                    guids.Add(new Guid("09d0c77b-e0d1-47ca-907e-997d19f2c8c2").ToString().ToLower()); // cheat code converter plugin
                    guids.Add(new Guid("7b0b9c38-8774-491a-8d9b-3255eddf1407").ToString().ToLower()); // emulator memory map plugin
                    guids.Add(new Guid("bbd24cd2-5ab0-470c-9e32-6a9458025855").ToString().ToLower()); // rva calculator plugin
                    guids.Add(new Guid("de686ea8-3f5f-479b-b742-5b13d93cb579").ToString().ToLower()); // scrathpad plugin
                    break;
                default:
                    throw new InvalidPluginTypeException(string.Format("'{0}' is not a valid plugin type", t.Name));
            }


            return guids.ToArray();
        }

        public bool IsKnownPluginName<T>(string plugin_name, out T plugin) where T : IPluginBase
        {
            plugin = default(T);
            bool known = false;

            Type t = typeof(T);
            string name = t.Name.ToLower();
            switch (name)
            {
                case "iconfigplugin":
                    if (LoadedConfigPlugins.Count > 0)
                    {
                        foreach (var p in LoadedConfigPlugins)
                        {
                            if (p.Name.ToLower() == plugin_name.ToLower())
                            {
                                plugin = (T)p;
                                known = true;
                                break;
                            }
                        }
                    }
                    break;
                case "iinputplugin":
                    if (LoadedInputPlugins.Count > 0)
                    {
                        foreach (var p in LoadedInputPlugins)
                        {
                            if (p.Name.ToLower() == plugin_name.ToLower())
                            {
                                plugin = (T)p;
                                known = true;
                                break;
                            }
                        }
                    }
                    break;
                case "iwindowplugin":
                    if (LoadedWindowPlugins.Count > 0)
                    {
                        foreach (var p in LoadedWindowPlugins)
                        {
                            if (p.Name.ToLower() == plugin_name.ToLower())
                            {
                                plugin = (T)p;
                                known = true;
                                break;
                            }
                        }
                    }
                    break;
                case "iusercontrolplugin":
                    if (LoadedUserControlPlugins.Count > 0)
                    {
                        foreach (var p in LoadedUserControlPlugins)
                        {
                            if (p.Name.ToLower() == plugin_name.ToLower())
                            {
                                plugin = (T)p;
                                known = true;
                                break;
                            }
                        }
                    }
                    break;
                default:
                    throw new InvalidPluginTypeException(string.Format("'{0}' is not a valid plugin type", t.Name));
            }


            return known;
        }
        public bool IsKnownPluginGuid<T>(string plugin_guid, out T plugin) where T : IPluginBase
        {
            plugin = default(T);
            bool known = false;
            var guids = GetKnownPluginGuids<T>();
            known = guids.ToList().Contains(plugin_guid.ToLower());

            if (known)
            {
                Type t = typeof(T);
                string name = t.Name.ToLower();
                switch (name)
                {
                    case "iconfigplugin":
                        if (LoadedConfigPlugins.Count > 0)
                        {
                            foreach (var p in LoadedConfigPlugins)
                            {
                                if (p.ID == new Guid(plugin_guid))
                                {
                                    plugin = (T)p;
                                    break;
                                }
                            }
                        }
                        break;
                    case "iinputplugin":
                        if (LoadedInputPlugins.Count > 0)
                        {
                            foreach (var p in LoadedInputPlugins)
                            {
                                if (p.ID == new Guid(plugin_guid))
                                {
                                    plugin = (T)p;
                                    break;
                                }
                            }
                        }
                        break;
                    case "iwindowplugin":
                        if (LoadedWindowPlugins.Count > 0)
                        {
                            foreach (var p in LoadedWindowPlugins)
                            {
                                if (p.ID == new Guid(plugin_guid))
                                {
                                    plugin = (T)p;
                                    break;
                                }
                            }
                        }
                        break;
                    case "iusercontrolplugin":
                        if (LoadedUserControlPlugins.Count > 0)
                        {
                            foreach (var p in LoadedUserControlPlugins)
                            {
                                if (p.ID == new Guid(plugin_guid))
                                {
                                    plugin = (T)p;
                                    break;
                                }
                            }
                        }
                        break;
                    default:
                        throw new InvalidPluginTypeException(string.Format("'{0}' is not a valid plugin type", t.Name));
                }
            }

            return known;
        }

        public void LoadPlugins() { LoadPlugins(false); }
        public void LoadPlugins(bool silent)
        {
            try
            {
                if (!silent)
                    gLog.Info.WriteLine("Loading Plugins...");

                string PluginPath = string.Format(@"{0}\Plugins", typeof(PluginLoader).Assembly.Location.Replace(@"\RomCheater.PluginFramework.dll", ""));
                if (!silent)
                    gLog.Debug.WriteLine("Plugins Path: {0}", PluginPath);
                List<string> dlls = new List<string>(Directory.GetFiles(PluginPath, "*.dll"));
                // also load any default plugins from the framework
                dlls.Add(typeof(PluginLoader).Assembly.Location);

                if (!silent)
                    gLog.Debug.WriteLine("  Found: {0} plugin dlls", dlls.Count);
                foreach (string dll in dlls)
                {
                    FileInfo fi = new FileInfo(dll);
                    if (!silent)
                        gLog.Debug.WriteLine("    plugin[{0}]: {1}", dlls.IndexOf(dll), fi.Name);
                    GetConfigPluginsFromDll(fi);
                    GetInputPluginsFromDll(fi);
                    GetWindowPluginsFromDll(fi);
                    GetUserControlPluginsFromDll(fi);
                }

                
                if (!silent)
                    gLog.Info.WriteLine("  Loaded {0} config plugins", LoadedConfigPlugins.Count);
                if (!silent)
                    gLog.Info.WriteLine("  Loaded {0} input plugins", LoadedInputPlugins.Count);
                if (!silent)
                    gLog.Info.WriteLine("  Loaded {0} window plugins", LoadedWindowPlugins.Count);
                if (!silent)
                    gLog.Info.WriteLine("  Loaded {0} usercontrol plugins", LoadedUserControlPlugins.Count);
                if (!silent)
                    gLog.Info.WriteLine("Plugins Loaded.");
            }
            catch (ReflectionTypeLoadException ex)
            {
                StringBuilder builder = new StringBuilder();
                if (ex.LoaderExceptions.Count() > 0)
                {
                    foreach (Exception c in ex.LoaderExceptions)
                    {
                        builder.AppendLine(c.ToString());
                    }
                }
                if (!silent)
                    gLog.Error.WriteLine("Failed to load one or more plugins{0}Possible Reason:{0}{1}", System.Environment.NewLine, builder.ToString());
            }
            catch (Exception ex)
            {
                if (!silent)
                    gLog.Error.WriteLine("Failed to load one or more plugins{0}Possible Reason:{0}{1}", System.Environment.NewLine, ex.ToString());
            }
        }
        public List<IConfigPlugin> LoadedConfigPlugins { get; private set; }
        public List<IInputPlugin> LoadedInputPlugins { get; private set; }
        public List<IWindowPlugin> LoadedWindowPlugins { get; private set; }
        public List<IUserControlPlugin> LoadedUserControlPlugins { get; private set; }

        public IConfigPlugin GetConfigPlugin(string t)
        {
            foreach (IConfigPlugin c in LoadedConfigPlugins) { if (c.ToString().ToLower() == t.ToLower()) { return c; } }
            return GetGenericConfigPlugin();
        }
        public IConfigPlugin GetGenericConfigPlugin()
        {
            foreach (IConfigPlugin c in LoadedConfigPlugins) { if (c.IsGenericPlugin || c.IsNullPlugin) { return c; } }
            return null;
        }
        public IInputPlugin GetInputPlugin(string t)
        {
            foreach (IInputPlugin c in LoadedInputPlugins) { if (c.ToString().ToLower() == t.ToLower()) { return c; } }
            return GetGenericInputPlugin();
        }
        public IInputPlugin GetGenericInputPlugin()
        {
            foreach (IInputPlugin c in LoadedInputPlugins) { if (c.IsGenericPlugin || c.IsNullPlugin) { return c; } }
            return null;
        }
        public IWindowPlugin GetWindowPlugin(string t)
        {
            foreach (IWindowPlugin c in LoadedWindowPlugins) { if (c.ToString().ToLower() == t.ToLower()) { return c; } }
            return GetGenericWindowPlugin();
        }
        public IWindowPlugin GetGenericWindowPlugin()
        {
            foreach (IWindowPlugin c in LoadedWindowPlugins) { if (c.IsGenericPlugin || c.IsNullPlugin) { return c; } }
            return null;
        }
        public IUserControlPlugin GetUserControlPlugin()
        {
            foreach (IUserControlPlugin c in LoadedUserControlPlugins) { if (c.IsGenericPlugin || c.IsNullPlugin) { return c; } }
            return null;
        }
        #endregion

        private void GetConfigPluginsFromDll(FileInfo dll)
        {
            gLog.Debug.WriteLine("  Getting Config plugins contained in {0}", dll.Name);
            Assembly asm = Assembly.LoadFile(dll.FullName);
            List<Type> types = new List<Type>(asm.GetTypes());
            foreach (Type type in types)
            {
                if (type.BaseType == typeof(ConfigPlugin))
                {
                    ConstructorInfo ci = null;
                    ci = type.GetConstructor(new Type[] { });
                    if (ci == null)
                    {
                        throw new NullReferenceException(string.Format("Unable to bind to constructor for type: {0}", type.Name));
                    }
                    else
                    {
                        object o = ci.Invoke(new object[] { });
                        IConfigPlugin c = (IConfigPlugin)o;
                        if (c == null)
                        {
                            throw new NullReferenceException(string.Format("Failed to cast type {0} to IConfigPlugin", type.Name));
                        }
                        else
                        {
                            gLog.Debug.WriteLine("    Loaded Config Plugin [name={0}] from {1}", c.Name, dll.Name);
                            LoadedConfigPlugins.Add(c);
                        }
                    }
                }
            }
        }
        private void GetInputPluginsFromDll(FileInfo dll)
        {
            gLog.Debug.WriteLine("  Getting Input plugins contained in {0}", dll.Name);
            Assembly asm = Assembly.LoadFile(dll.FullName);
            List<Type> types = new List<Type>(asm.GetTypes());
            foreach (Type type in types)
            {
                if (type.BaseType == typeof(InputPlugin))
                {
                    ConstructorInfo ci = null;
                    ci = type.GetConstructor(new Type[] { });
                    if (ci == null)
                    {
                        throw new NullReferenceException(string.Format("Unable to bind to constructor for type: {0}", type.Name));
                    }
                    else
                    {
                        object o = ci.Invoke(new object[] { });
                        IInputPlugin c = (IInputPlugin)o;
                        if (c == null)
                        {
                            throw new NullReferenceException(string.Format("Failed to cast type {0} to IConfigPlugin", type.Name));
                        }
                        else
                        {
                            gLog.Debug.WriteLine("    Loaded Input Plugin [name={0}] from {1}", c.Name, dll.Name);
                            LoadedInputPlugins.Add(c);
                        }
                    }
                }
            }
        }
        private void GetWindowPluginsFromDll(FileInfo dll)
        {
            gLog.Debug.WriteLine("  Getting Window plugins contained in {0}", dll.Name);
            Assembly asm = Assembly.LoadFile(dll.FullName);
            List<Type> types = new List<Type>(asm.GetTypes());
            foreach (Type type in types)
            {
                if (type.BaseType == typeof(WindowPlugin))
                {
                    ConstructorInfo ci = null;
                    ci = type.GetConstructor(new Type[] { });
                    if (ci == null)
                    {
                        throw new NullReferenceException(string.Format("Unable to bind to constructor for type: {0}", type.Name));
                    }
                    else
                    {
                        object o = ci.Invoke(new object[] { });
                        IWindowPlugin c = (IWindowPlugin)o;
                        if (c == null)
                        {
                            throw new NullReferenceException(string.Format("Failed to cast type {0} to IConfigPlugin", type.Name));
                        }
                        else
                        {
                            gLog.Debug.WriteLine("    Loaded Window Plugin [name={0}] from {1}", c.Name, dll.Name);
                            LoadedWindowPlugins.Add(c);
                        }
                    }
                }
            }
        }
        private void GetUserControlPluginsFromDll(FileInfo dll)
        {
            gLog.Debug.WriteLine("  Getting UserControl plugins contained in {0}", dll.Name);
            Assembly asm = Assembly.LoadFile(dll.FullName);
            List<Type> types = new List<Type>(asm.GetTypes());
            foreach (Type type in types)
            {
                if (type.BaseType == typeof(UserControlPlugin))
                {
                    ConstructorInfo ci = null;
                    ci = type.GetConstructor(new Type[] { });
                    if (ci == null)
                    {
                        throw new NullReferenceException(string.Format("Unable to bind to constructor for type: {0}", type.Name));
                    }
                    else
                    {
                        object o = ci.Invoke(new object[] { });
                        IUserControlPlugin c = (IUserControlPlugin)o;
                        if (c == null)
                        {
                            throw new NullReferenceException(string.Format("Failed to cast type {0} to IConfigPlugin", type.Name));
                        }
                        else
                        {
                            gLog.Debug.WriteLine("    Loaded UserControl Plugin [name={0}] from {1}", c.Name, dll.Name);
                            LoadedUserControlPlugins.Add(c);
                        }
                    }
                }
            }
        }        
    }
}
1	#region Logging Defines
2	// include this any class or method that required logging, and comment-out what is not needed
3
4	#region Enabled logging levels
5	#define LOGGING_ENABLE_INFO
6	#define LOGGING_ENABLE_WARN
7	#define LOGGING_ENABLE_DEBUG
8	#define LOGGING_ENABLE_VERBOSEDEBUG
9	#define LOGGING_ENABLE_ERROR
10	#define LOGGING_ENABLE_VERBOSEERROR
11	#define LOGGING_ENABLE_PROFILER
12	#endregion
13	#endregion
14	using System;
15	using System.Collections.Generic;
16	using System.Linq;
17	using System.Text;
18	using RomCheater.Logging;
19	using System.IO;
20	using System.Reflection;
21	using RomCheater.Core;
22	using System.Runtime.Serialization;
23	using System.Security;
24	using Enterprise.Logging;
25
26	namespace RomCheater.PluginFramework.Core
27	{
28	#region plugin loader execeptions
29	public class PluginNotFoundException : System.Exception
30	{
31	public PluginNotFoundException() : base() { }
32	public PluginNotFoundException(string message) : base(message) { }
33	public PluginNotFoundException(string message, Exception innerException) : base(message, innerException) { }
34	[SecuritySafeCritical]
35	protected PluginNotFoundException(SerializationInfo info, StreamingContext context) : base(info, context) { }
36	}
37	public class InvalidPluginException : System.Exception
38	{
39	public InvalidPluginException() : base() { }
40	public InvalidPluginException(string message) : base(message) { }
41	public InvalidPluginException(string message, Exception innerException) : base(message, innerException) { }
42	[SecuritySafeCritical]
43	protected InvalidPluginException(SerializationInfo info, StreamingContext context) : base(info, context) { }
44	}
45	public class InvalidPluginTypeException : System.Exception
46	{
47	public InvalidPluginTypeException() : base() { }
48	public InvalidPluginTypeException(string message) : base(message) { }
49	public InvalidPluginTypeException(string message, Exception innerException) : base(message, innerException) { }
50	[SecuritySafeCritical]
51	protected InvalidPluginTypeException(SerializationInfo info, StreamingContext context) : base(info, context) { }
52	}
53	#endregion
54
55	public class PluginLoader : IPluginLoader
56	{
57
58	public PluginLoader()
59	{
60	LoadedConfigPlugins = new List<IConfigPlugin>();
61	LoadedInputPlugins = new List<IInputPlugin>();
62	LoadedWindowPlugins = new List<IWindowPlugin>();
63	LoadedUserControlPlugins = new List<IUserControlPlugin>();
64	}
65	#region IPluginLoader Members
66
67	public T GetPluginByName<T>(string name) where T : IPluginBase
68	{
69	T plugin = default(T);
70	if (string.IsNullOrEmpty(name))
71	{
72	throw new ArgumentException("name cannot be null or an empty string", "name");
73	}
74
75	bool known = IsKnownPluginName<T>(name, out plugin);
76	if (known)
77	{
78	if (plugin != null)
79	{
80	return plugin;
81	}
82	else
83	{
84	throw new InvalidPluginException(string.Format("Plugin name: '{0}' is known, but the returned plugin was null", name));
85	}
86	}
87	else
88	{
89	if (LoadedConfigPlugins.Count > 0)
90	{
91	foreach (var p in LoadedConfigPlugins)
92	{
93	if (p.Name.ToLower() == name.ToLower())
94	{
95	plugin = (T)p;
96	known = true;
97	break;
98	}
99	}
100	}
101	if (LoadedInputPlugins.Count > 0)
102	{
103	foreach (var p in LoadedInputPlugins)
104	{
105	if (p.Name.ToLower() == name.ToLower())
106	{
107	plugin = (T)p;
108	known = true;
109	break;
110	}
111	}
112	}
113	if (LoadedWindowPlugins.Count > 0)
114	{
115	foreach (var p in LoadedWindowPlugins)
116	{
117	if (p.Name.ToLower() == name.ToLower())
118	{
119	plugin = (T)p;
120	known = true;
121	break;
122	}
123	}
124	}
125	if (LoadedUserControlPlugins.Count > 0)
126	{
127	foreach (var p in LoadedUserControlPlugins)
128	{
129	if (p.Name.ToLower() == name.ToLower())
130	{
131	plugin = (T)p;
132	known = true;
133	break;
134	}
135	}
136	}
137	if (known)
138	{
139	return plugin;
140	}
141	else
142	{
143	throw new PluginNotFoundException(string.Format("Could not find a plugin with name: '{0}'", name));
144	}
145	}
146	}
147	public T GetPluginByGuid<T>(string plugin_guid) where T : IPluginBase
148	{
149	T plugin = default(T);
150
151	if (string.IsNullOrEmpty(plugin_guid))
152	{
153	throw new ArgumentException("plugin_plugin cannot be null or an empty string", "plugin_guid");
154	}
155
156	bool known = IsKnownPluginGuid<T>(plugin_guid, out plugin);
157	if (known)
158	{
159	if (plugin != null)
160	{
161	return plugin;
162	}
163	else
164	{
165	throw new InvalidPluginException(string.Format("Plugin guid: '{0}' is known, but the returned plugin was null", plugin_guid));
166	}
167	}
168	else
169	{
170	if (LoadedConfigPlugins.Count > 0)
171	{
172	foreach (var p in LoadedConfigPlugins)
173	{
174	if (p.ID == new Guid(plugin_guid))
175	{
176	plugin = (T)p;
177	known = true;
178	break;
179	}
180	}
181	}
182	if (LoadedInputPlugins.Count > 0)
183	{
184	foreach (var p in LoadedInputPlugins)
185	{
186	if (p.ID == new Guid(plugin_guid))
187	{
188	plugin = (T)p;
189	known = true;
190	break;
191	}
192	}
193	}
194	if (LoadedWindowPlugins.Count > 0)
195	{
196	foreach (var p in LoadedWindowPlugins)
197	{
198	if (p.ID == new Guid(plugin_guid))
199	{
200	plugin = (T)p;
201	known = true;
202	break;
203	}
204	}
205	}
206	if (LoadedUserControlPlugins.Count > 0)
207	{
208	foreach (var p in LoadedUserControlPlugins)
209	{
210	if (p.ID == new Guid(plugin_guid))
211	{
212	plugin = (T)p;
213	known = true;
214	break;
215	}
216	}
217	}
218	}
219	if (known)
220	{
221	return plugin;
222	}
223	else
224	{
225	throw new PluginNotFoundException(string.Format("Could not find a plugin with guid: '{0}'", plugin_guid));
226	}
227	}
228	public string[] GetKnownPluginGuids<T>() where T : IPluginBase
229	{
230	Type t = typeof(T);
231	string name = t.Name.ToLower();
232
233	List<string> guids = new List<string>();
234	guids.Add(new Guid().ToString().ToLower()); // add null guids
235	switch (name)
236	{
237	case "iconfigplugin":
238	guids.Add(new Guid("478e225b-c3e8-9280-57ca-384b884fc4cc").ToString().ToLower()); // generic config
239	break;
240	case "iinputplugin":
241	// no known plugins (other than null at this time)
242	break;
243	case "iwindowplugin":
244	// no known plugins (other than null at this time)
245	break;
246	case "iusercontrolplugin":
247	guids.RemoveAt(0); // userplugins should not have a null plugin guid
248	guids.Add(new Guid("09d0c77b-e0d1-47ca-907e-997d19f2c8c2").ToString().ToLower()); // cheat code converter plugin
249	guids.Add(new Guid("7b0b9c38-8774-491a-8d9b-3255eddf1407").ToString().ToLower()); // emulator memory map plugin
250	guids.Add(new Guid("bbd24cd2-5ab0-470c-9e32-6a9458025855").ToString().ToLower()); // rva calculator plugin
251	guids.Add(new Guid("de686ea8-3f5f-479b-b742-5b13d93cb579").ToString().ToLower()); // scrathpad plugin
252	break;
253	default:
254	throw new InvalidPluginTypeException(string.Format("'{0}' is not a valid plugin type", t.Name));
255	}
256
257
258	return guids.ToArray();
259	}
260
261	public bool IsKnownPluginName<T>(string plugin_name, out T plugin) where T : IPluginBase
262	{
263	plugin = default(T);
264	bool known = false;
265
266	Type t = typeof(T);
267	string name = t.Name.ToLower();
268	switch (name)
269	{
270	case "iconfigplugin":
271	if (LoadedConfigPlugins.Count > 0)
272	{
273	foreach (var p in LoadedConfigPlugins)
274	{
275	if (p.Name.ToLower() == plugin_name.ToLower())
276	{
277	plugin = (T)p;
278	known = true;
279	break;
280	}
281	}
282	}
283	break;
284	case "iinputplugin":
285	if (LoadedInputPlugins.Count > 0)
286	{
287	foreach (var p in LoadedInputPlugins)
288	{
289	if (p.Name.ToLower() == plugin_name.ToLower())
290	{
291	plugin = (T)p;
292	known = true;
293	break;
294	}
295	}
296	}
297	break;
298	case "iwindowplugin":
299	if (LoadedWindowPlugins.Count > 0)
300	{
301	foreach (var p in LoadedWindowPlugins)
302	{
303	if (p.Name.ToLower() == plugin_name.ToLower())
304	{
305	plugin = (T)p;
306	known = true;
307	break;
308	}
309	}
310	}
311	break;
312	case "iusercontrolplugin":
313	if (LoadedUserControlPlugins.Count > 0)
314	{
315	foreach (var p in LoadedUserControlPlugins)
316	{
317	if (p.Name.ToLower() == plugin_name.ToLower())
318	{
319	plugin = (T)p;
320	known = true;
321	break;
322	}
323	}
324	}
325	break;
326	default:
327	throw new InvalidPluginTypeException(string.Format("'{0}' is not a valid plugin type", t.Name));
328	}
329
330
331	return known;
332	}
333	public bool IsKnownPluginGuid<T>(string plugin_guid, out T plugin) where T : IPluginBase
334	{
335	plugin = default(T);
336	bool known = false;
337	var guids = GetKnownPluginGuids<T>();
338	known = guids.ToList().Contains(plugin_guid.ToLower());
339
340	if (known)
341	{
342	Type t = typeof(T);
343	string name = t.Name.ToLower();
344	switch (name)
345	{
346	case "iconfigplugin":
347	if (LoadedConfigPlugins.Count > 0)
348	{
349	foreach (var p in LoadedConfigPlugins)
350	{
351	if (p.ID == new Guid(plugin_guid))
352	{
353	plugin = (T)p;
354	break;
355	}
356	}
357	}
358	break;
359	case "iinputplugin":
360	if (LoadedInputPlugins.Count > 0)
361	{
362	foreach (var p in LoadedInputPlugins)
363	{
364	if (p.ID == new Guid(plugin_guid))
365	{
366	plugin = (T)p;
367	break;
368	}
369	}
370	}
371	break;
372	case "iwindowplugin":
373	if (LoadedWindowPlugins.Count > 0)
374	{
375	foreach (var p in LoadedWindowPlugins)
376	{
377	if (p.ID == new Guid(plugin_guid))
378	{
379	plugin = (T)p;
380	break;
381	}
382	}
383	}
384	break;
385	case "iusercontrolplugin":
386	if (LoadedUserControlPlugins.Count > 0)
387	{
388	foreach (var p in LoadedUserControlPlugins)
389	{
390	if (p.ID == new Guid(plugin_guid))
391	{
392	plugin = (T)p;
393	break;
394	}
395	}
396	}
397	break;
398	default:
399	throw new InvalidPluginTypeException(string.Format("'{0}' is not a valid plugin type", t.Name));
400	}
401	}
402
403	return known;
404	}
405
406	public void LoadPlugins() { LoadPlugins(false); }
407	public void LoadPlugins(bool silent)
408	{
409	try
410	{
411	if (!silent)
412	gLog.Info.WriteLine("Loading Plugins...");
413
414	string PluginPath = string.Format(@"{0}\Plugins", typeof(PluginLoader).Assembly.Location.Replace(@"\RomCheater.PluginFramework.dll", ""));
415	if (!silent)
416	gLog.Debug.WriteLine("Plugins Path: {0}", PluginPath);
417	List<string> dlls = new List<string>(Directory.GetFiles(PluginPath, "*.dll"));
418	// also load any default plugins from the framework
419	dlls.Add(typeof(PluginLoader).Assembly.Location);
420
421	if (!silent)
422	gLog.Debug.WriteLine(" Found: {0} plugin dlls", dlls.Count);
423	foreach (string dll in dlls)
424	{
425	FileInfo fi = new FileInfo(dll);
426	if (!silent)
427	gLog.Debug.WriteLine(" plugin[{0}]: {1}", dlls.IndexOf(dll), fi.Name);
428	GetConfigPluginsFromDll(fi);
429	GetInputPluginsFromDll(fi);
430	GetWindowPluginsFromDll(fi);
431	GetUserControlPluginsFromDll(fi);
432	}
433
434
435
436	if (!silent)
437	gLog.Info.WriteLine(" Loaded {0} config plugins", LoadedConfigPlugins.Count);
438	if (!silent)
439	gLog.Info.WriteLine(" Loaded {0} input plugins", LoadedInputPlugins.Count);
440	if (!silent)
441	gLog.Info.WriteLine(" Loaded {0} window plugins", LoadedWindowPlugins.Count);
442	if (!silent)
443	gLog.Info.WriteLine(" Loaded {0} usercontrol plugins", LoadedUserControlPlugins.Count);
444	if (!silent)
445	gLog.Info.WriteLine("Plugins Loaded.");
446	}
447	catch (ReflectionTypeLoadException ex)
448	{
449	StringBuilder builder = new StringBuilder();
450	if (ex.LoaderExceptions.Count() > 0)
451	{
452	foreach (Exception c in ex.LoaderExceptions)
453	{
454	builder.AppendLine(c.ToString());
455	}
456	}
457	if (!silent)
458	gLog.Error.WriteLine("Failed to load one or more plugins{0}Possible Reason:{0}{1}", System.Environment.NewLine, builder.ToString());
459	}
460	catch (Exception ex)
461	{
462	if (!silent)
463	gLog.Error.WriteLine("Failed to load one or more plugins{0}Possible Reason:{0}{1}", System.Environment.NewLine, ex.ToString());
464	}
465	}
466	public List<IConfigPlugin> LoadedConfigPlugins { get; private set; }
467	public List<IInputPlugin> LoadedInputPlugins { get; private set; }
468	public List<IWindowPlugin> LoadedWindowPlugins { get; private set; }
469	public List<IUserControlPlugin> LoadedUserControlPlugins { get; private set; }
470
471	public IConfigPlugin GetConfigPlugin(string t)
472	{
473	foreach (IConfigPlugin c in LoadedConfigPlugins) { if (c.ToString().ToLower() == t.ToLower()) { return c; } }
474	return GetGenericConfigPlugin();
475	}
476	public IConfigPlugin GetGenericConfigPlugin()
477	{
478	foreach (IConfigPlugin c in LoadedConfigPlugins) { if (c.IsGenericPlugin \|\| c.IsNullPlugin) { return c; } }
479	return null;
480	}
481	public IInputPlugin GetInputPlugin(string t)
482	{
483	foreach (IInputPlugin c in LoadedInputPlugins) { if (c.ToString().ToLower() == t.ToLower()) { return c; } }
484	return GetGenericInputPlugin();
485	}
486	public IInputPlugin GetGenericInputPlugin()
487	{
488	foreach (IInputPlugin c in LoadedInputPlugins) { if (c.IsGenericPlugin \|\| c.IsNullPlugin) { return c; } }
489	return null;
490	}
491	public IWindowPlugin GetWindowPlugin(string t)
492	{
493	foreach (IWindowPlugin c in LoadedWindowPlugins) { if (c.ToString().ToLower() == t.ToLower()) { return c; } }
494	return GetGenericWindowPlugin();
495	}
496	public IWindowPlugin GetGenericWindowPlugin()
497	{
498	foreach (IWindowPlugin c in LoadedWindowPlugins) { if (c.IsGenericPlugin \|\| c.IsNullPlugin) { return c; } }
499	return null;
500	}
501	public IUserControlPlugin GetUserControlPlugin()
502	{
503	foreach (IUserControlPlugin c in LoadedUserControlPlugins) { if (c.IsGenericPlugin \|\| c.IsNullPlugin) { return c; } }
504	return null;
505	}
506	#endregion
507
508	private void GetConfigPluginsFromDll(FileInfo dll)
509	{
510	gLog.Debug.WriteLine(" Getting Config plugins contained in {0}", dll.Name);
511	Assembly asm = Assembly.LoadFile(dll.FullName);
512	List<Type> types = new List<Type>(asm.GetTypes());
513	foreach (Type type in types)
514	{
515	if (type.BaseType == typeof(ConfigPlugin))
516	{
517	ConstructorInfo ci = null;
518	ci = type.GetConstructor(new Type[] { });
519	if (ci == null)
520	{
521	throw new NullReferenceException(string.Format("Unable to bind to constructor for type: {0}", type.Name));
522	}
523	else
524	{
525	object o = ci.Invoke(new object[] { });
526	IConfigPlugin c = (IConfigPlugin)o;
527	if (c == null)
528	{
529	throw new NullReferenceException(string.Format("Failed to cast type {0} to IConfigPlugin", type.Name));
530	}
531	else
532	{
533	gLog.Debug.WriteLine(" Loaded Config Plugin [name={0}] from {1}", c.Name, dll.Name);
534	LoadedConfigPlugins.Add(c);
535	}
536	}
537	}
538	}
539	}
540	private void GetInputPluginsFromDll(FileInfo dll)
541	{
542	gLog.Debug.WriteLine(" Getting Input plugins contained in {0}", dll.Name);
543	Assembly asm = Assembly.LoadFile(dll.FullName);
544	List<Type> types = new List<Type>(asm.GetTypes());
545	foreach (Type type in types)
546	{
547	if (type.BaseType == typeof(InputPlugin))
548	{
549	ConstructorInfo ci = null;
550	ci = type.GetConstructor(new Type[] { });
551	if (ci == null)
552	{
553	throw new NullReferenceException(string.Format("Unable to bind to constructor for type: {0}", type.Name));
554	}
555	else
556	{
557	object o = ci.Invoke(new object[] { });
558	IInputPlugin c = (IInputPlugin)o;
559	if (c == null)
560	{
561	throw new NullReferenceException(string.Format("Failed to cast type {0} to IConfigPlugin", type.Name));
562	}
563	else
564	{
565	gLog.Debug.WriteLine(" Loaded Input Plugin [name={0}] from {1}", c.Name, dll.Name);
566	LoadedInputPlugins.Add(c);
567	}
568	}
569	}
570	}
571	}
572	private void GetWindowPluginsFromDll(FileInfo dll)
573	{
574	gLog.Debug.WriteLine(" Getting Window plugins contained in {0}", dll.Name);
575	Assembly asm = Assembly.LoadFile(dll.FullName);
576	List<Type> types = new List<Type>(asm.GetTypes());
577	foreach (Type type in types)
578	{
579	if (type.BaseType == typeof(WindowPlugin))
580	{
581	ConstructorInfo ci = null;
582	ci = type.GetConstructor(new Type[] { });
583	if (ci == null)
584	{
585	throw new NullReferenceException(string.Format("Unable to bind to constructor for type: {0}", type.Name));
586	}
587	else
588	{
589	object o = ci.Invoke(new object[] { });
590	IWindowPlugin c = (IWindowPlugin)o;
591	if (c == null)
592	{
593	throw new NullReferenceException(string.Format("Failed to cast type {0} to IConfigPlugin", type.Name));
594	}
595	else
596	{
597	gLog.Debug.WriteLine(" Loaded Window Plugin [name={0}] from {1}", c.Name, dll.Name);
598	LoadedWindowPlugins.Add(c);
599	}
600	}
601	}
602	}
603	}
604	private void GetUserControlPluginsFromDll(FileInfo dll)
605	{
606	gLog.Debug.WriteLine(" Getting UserControl plugins contained in {0}", dll.Name);
607	Assembly asm = Assembly.LoadFile(dll.FullName);
608	List<Type> types = new List<Type>(asm.GetTypes());
609	foreach (Type type in types)
610	{
611	if (type.BaseType == typeof(UserControlPlugin))
612	{
613	ConstructorInfo ci = null;
614	ci = type.GetConstructor(new Type[] { });
615	if (ci == null)
616	{
617	throw new NullReferenceException(string.Format("Unable to bind to constructor for type: {0}", type.Name));
618	}
619	else
620	{
621	object o = ci.Invoke(new object[] { });
622	IUserControlPlugin c = (IUserControlPlugin)o;
623	if (c == null)
624	{
625	throw new NullReferenceException(string.Format("Failed to cast type {0} to IConfigPlugin", type.Name));
626	}
627	else
628	{
629	gLog.Debug.WriteLine(" Loaded UserControl Plugin [name={0}] from {1}", c.Name, dll.Name);
630	LoadedUserControlPlugins.Add(c);
631	}
632	}
633	}
634	}
635	}
636	}
637	}