public PluginInfo(String pluginID, int position, bool isActive, AbstractPlugin plugin)
{
this.pluginID = pluginID;
this.position = position;
this.isActive = isActive;
this.plugin = plugin;
}
public FigureParameters(AbstractPlugin figure) : this()
{
Type figureType = figure.GetType();
foreach (PropertyInfo pi in figureType.GetProperties())
{
if (pi.Name != "GraphicsPath" && pi.Name != "Pen")
{
this.AddLabel(pi.Name);
this.AddNumericUpDown(pi.Name, (int)pi.GetValue(figure));
}
}
this.Draw_button.Click += (sender, args) =>
{
foreach (PropertyInfo pi in figureType.GetProperties())
{
if (pi.Name != "GraphicsPath" && pi.Name != "Pen")
{
pi.SetValue(figure,
(int)(this.ElementsPanel.Controls[pi.Name + NumericUpDownPostfix] as NumericUpDown).Value);
}
}
this.DialogResult = DialogResult.OK;
};
}
/// <summary>
/// Runs the plugin stage with the specififed type
/// </summary>
/// <param name="type"></param>
/// <param name="stage">The stage of the current processing</param>
/// <param name="script">the script to be processed</param>
/// <param name="sourceManager"></param>
/// <param name="defTable">the definitions that are used</param>
/// <returns>True if the operation completed successfully</returns>
private bool RunPluginStage(PluginType type, ProcessStage stage, ISourceScript script, ISourceManager sourceManager, IDefinitions defTable)
{
List <AbstractPlugin> chain = AbstractPlugin.GetPluginsForStage(_plugins, type, stage);
bool ret = true;
if (type == PluginType.FULL_SCRIPT_PLUGIN)
{
ret = RunFullScriptStage(chain, stage, script, sourceManager, defTable);
}
else if (type == PluginType.LINE_PLUGIN_BEFORE || type == PluginType.LINE_PLUGIN_AFTER)
{
string[] src = script.GetSource();
RunLineStage(chain, stage, src);
script.SetSource(src);
}
if (!ret)
{
return(false);
}
return(true);
}
public MainForm()
{
InitializeComponent();
foreach (KeyValuePair <string, Type> pair in typeDictionary)
{
classBox.Items.Add(pair.Key);
}
foreach (KeyValuePair <string, AbstractSerializer> pair in serializers)
{
serList.Items.Add(pair.Key);
}
string[] files = Directory.GetFiles(".", "*.dll");
foreach (string path in files)
{
Type[] types = null;
var assembly = Assembly.LoadFrom(path);
if (assembly != null)
{
types = assembly.GetTypes();
foreach (Type type in types)
{
if (type.IsSubclassOf(typeof(AbstractPlugin)))
{
AbstractPlugin plugin = Activator.CreateInstance(type) as AbstractPlugin;
string name = plugin.GetName();
plugins.Add(name, plugin);
pluginsList.Items.Add(name);
}
}
}
}
}
/// <summary>
/// Runs the plugin stage with the specififed type
/// </summary>
/// <param name="type"></param>
/// <param name="stage">The stage of the current processing</param>
/// <param name="script">the script to be processed</param>
/// <param name="sourceManager"></param>
/// <param name="defTable">the definitions that are used</param>
/// <returns>True if the operation completed successfully</returns>
private bool RunPluginStage(PluginType type, ProcessStage stage, ISourceScript script,
ISourceManager sourceManager, IDefinitions defTable)
{
List <AbstractPlugin> chain = AbstractPlugin.GetPluginsForStage(plugins, type, stage);
bool ret = true;
if (type == PluginType.FullScriptPlugin)
{
ret = RunFullScriptStage(chain, stage, script, sourceManager, defTable);
}
else if (type == PluginType.LinePluginBefore || type == PluginType.LinePluginAfter)
{
string[] src = script.GetSource();
RunLineStage(chain, stage, src);
script.SetSource(src);
}
if (!ret)
{
return(false);
}
return(true);
}
public override void Save <T>(AbstractPlugin plugin, T obj)
{
using (var fs = new FileStream(fileName, FileMode.Create, FileAccess.Write))
{
var serializer = new BinaryFormatter();
serializer.Serialize(fs, obj);
}
}
public override T Load <T>(AbstractPlugin plugin)
{
using (var fs = new FileStream(fileName, FileMode.Open, FileAccess.Read))
{
var serializer = new BinaryFormatter();
return(serializer.Deserialize(fs) as T);
}
}
/// <summary>
/// A commandlet represents the abstract idea of the typical IRC command represented with a start-character (!) and a string for identify. All the parsing will be done
/// by the bot, you only get exactly the events you registered to. For example: you can register an event which is only thrown if used in a private message by certain users,
/// or in a certain channel.
/// </summary>
/// <param name="command">the command string including initial charakter. like "!example" </param>
/// <param name="helptext">A help for this certain command which should be displayed by the !help command</param>
/// <param name="handler">The name of the method which should be called, can be private</param>
/// <param name="plugin">this (the class where this command is provided)</param>
public PluginCommand(string command, string helptext, EventHandler<CommandEventArgs> handler, AbstractPlugin plugin)
{
ExportedCommand = command;
HelpText = helptext;
HandlerName = handler.Method.Name;
Owner = plugin.FullName;
SourcePlugin = plugin.FullName;
}
public SIMLHub_Old() : base("SIMLHub")
{
bot = new SimlBot();
// Soon it will be substracted
this.adapterCount = bot.Adapters.Count;
// Add all adapters
pluginAdapterPathAndTypes = helper.GetAllSIMLHubPluginIndexAdapterPathAndTypes();
Console.Write("[SIMLHub] Adapters loading : ");
foreach (var adapterPair in pluginAdapterPathAndTypes)
{
Assembly assembly = Assembly.LoadFrom(adapterPair.Key);
foreach (var typename in adapterPair.Value)
{
try
{
IAdapter adapter = (IAdapter)assembly.CreateInstance(typename);
AbstractPlugin simlHubPlugin = (AbstractPlugin)adapter;
this.Hub.PassThrough(simlHubPlugin.Hub);
// Add to bot in not null
if (adapter != null)
{
bot.Adapters.Add(adapter);
}
}
catch { /*Ignore*/ }
}
}
Console.WriteLine("success");
// Now final value is set
this.adapterCount = bot.Adapters.Count - this.adapterCount;
// Add all index.siml files
Console.Write("[SIMLHub] Index siml merge : ");
string mergedIndexSimlPackage = helper.GetAllIndexSimlPackage();
Console.WriteLine("success");
Console.Write("[SIMLHub] Merged index siml : ");
bot.PackageManager.LoadFromString(mergedIndexSimlPackage);
Console.WriteLine("success");
// Subscribe to IUserResponse for input
hub.Subscribe <IUserResponse>(this.GetBotReponse);
}
/// <summary>
/// Add an individual to the master list.
/// </summary>
/// <param name="plugin">The plugin instance to add.</param>
public bool AddPlugin(AbstractPlugin plugin)
{
lock (m_pluginsAvailable)
{
if (m_pluginsAvailable.ContainsKey(plugin.UUID))
{
this.Log().Warn("Plugin with UUID '{0}' is already registered.", plugin.UUID);
return(false);
}
this.Log().Debug("Adding plugin {0} (ID = '{1}')", plugin.GetType().Name, plugin.UUID);
m_pluginsAvailable[plugin.UUID] = plugin;
}
return(true);
}
private void Serialize()
{
if (serializers.TryGetValue(serList.SelectedItem.ToString(), out AbstractSerializer ser))
{
AbstractPlugin plugin = null;
object o = pluginsList.SelectedItem;
if (o != null)
{
string pluginName = o.ToString();
plugin = plugins[pluginName];
}
ser.Save(plugin, objects);
}
}
public override void Save <T>(AbstractPlugin plugin, T obj)
{
using (var fs = new FileStream(fileName, FileMode.Create, FileAccess.Write))
{
string text = JsonConvert.SerializeObject(obj);
byte[] buffer = Encoding.ASCII.GetBytes(text);
if (plugin != null)
{
buffer = plugin.Encrypt(buffer);
}
fs.Write(buffer, 0, buffer.Length);
fs.Flush();
}
}
/// <summary>
/// Converts the Plugin to a basic markdown text that can be used to generate readmes.
/// </summary>
/// <param name="plugin">The plugin to list</param>
/// <returns>The plugin description in markdown</returns>
public static string[] ToMarkdown(this AbstractPlugin plugin)
{
List <string> ret = new List <string>
{
"______________________________________________",
"#### " + plugin.GetType().Name + " Information:",
"",
"* Prefix: " + plugin.Prefix.Unpack(", "),
"* Commands:",
""
};
ret.AddRange(ToMarkdown(plugin.Info));
return(ret.ToArray());
}
public override T Load <T>(AbstractPlugin plugin)
{
using (var fs = new FileStream(fileName, FileMode.Open, FileAccess.Read))
{
int length = (int)fs.Length;
byte[] buffer = new byte[length];
fs.Read(buffer, 0, length);
if (plugin != null)
{
buffer = plugin.Decrypt(buffer);
}
string text = Encoding.ASCII.GetString(buffer);
return(JsonConvert.DeserializeObject <T>(text));
}
}
private void Deserialize()
{
if (serializers.TryGetValue(serList.SelectedItem.ToString(), out AbstractSerializer ser))
{
AbstractPlugin plugin = null;
object o = pluginsList.SelectedItem;
if (o != null)
{
string pluginName = o.ToString();
plugin = plugins[pluginName];
}
objects = ser.Load <List <Device> >(plugin);
FillList();
}
}
/// <summary>
/// Returns a list of command info.
/// </summary>
/// <param name="plugin"></param>
/// <param name="listCommands"></param>
/// <returns></returns>
public static List <string> ListInfo(this AbstractPlugin plugin, bool listCommands)
{
List <string> ret = new List <string>
{
"Plugin Name: " + plugin.GetType().Name,
"Plugin Namespace: " + plugin.GetType().Namespace,
"Plugin Version: " + plugin.GetType().Assembly.GetName().Version,
"Plugin Include Global: " + plugin.IncludeGlobal,
"Plugin Prefixes: " + plugin.Prefix.Unpack(", ")
};
if (listCommands)
{
ret.Add("Plugin Commands:");
ret.AddRange(ListAllCommands(plugin.Info, plugin.Prefix));
}
ret.Add("");
return(ret);
}
public void InterpretPluginArguments(string[] pluginArgs, AbstractPlugin abstractPlugin)
{
var isSuccessful = Parser.Default.ParseArguments(pluginArgs, abstractPlugin, (verb, subOptions) => {
try
{
var settings = InEngineSettings.Make();
if (subOptions == null && (pluginArgs.Contains("-h") || pluginArgs.Contains("--help")))
{
ExitWithSuccess();
}
else if (subOptions == null)
{
ExitWithFailure("");
}
var command = subOptions as AbstractCommand;
if (command is AbstractCommand)
{
(command as AbstractCommand).Name = verb.Normalize();
}
if (command is IHasQueueSettings)
{
(command as IHasQueueSettings).QueueSettings = settings.Queue;
}
command.MailSettings = settings.Mail;
command.Run();
ExitWithSuccess();
}
catch (Exception exception)
{
ExitWithFailure(exception);
}
});
if (!isSuccessful)
{
ExitWithFailure(new CommandFailedException("Could not parse plugin arguments. Use -h, --help for usage."));
}
}
/// <summary>
/// Converts the Plugin to a basic markdown text that can be used to generate readmes.
/// </summary>
/// <param name="plugin"></param>
/// <returns></returns>
public static string[] ToMarkdown(this AbstractPlugin plugin)
{
List <string> ret = new List <string>()
{
"______________________________________________",
"#### " + plugin.GetType().Name + " Information:",
"",
"* Prefix: " + plugin.Prefix.Unpack(", "),
"* Commands:",
""
};
string tab = "\t\t";
for (int i = 0; i < plugin.Info.Count; i++)
{
string[] helpt = plugin.Info[i].HelpText.Split("\n");
ret.Add(tab + plugin.Info[i].Command + "/" + plugin.Info[i].ShortCut);
ret.Add(tab + "\t" + helpt.Unpack("\n\t" + tab));
}
return(ret.ToArray());
}
public abstract T Load <T>(AbstractPlugin plugin) where T : class;
/// <summary>
/// A commandlet represents the abstract idea of the typical IRC command represented with a start-character (!) and a string for identify. All the parsing will be done
/// by the bot, you only get exactly the events you registered to. For example: you can register an event which is only thrown if used in a private message by certain users,
/// or in a certain channel.
/// </summary>
/// <param name="command">the command string including initial charakter. like "!example" </param>
/// <param name="helptext">A help for this certain command which should be displayed by the !help command</param>
/// <param name="handler">The name of the method which should be called, can be private</param>
/// <param name="plugin">this (the class where this command is provided)</param>
public PluginCommand(string command, string helptext, EventHandler <CommandEventArgs> handler, AbstractPlugin plugin)
{
ExportedCommand = command;
HelpText = helptext;
HandlerName = handler.Method.Name;
Owner = plugin.FullName;
SourcePlugin = plugin.FullName;
}
public PluginHost(AbstractPlugin plugin)
{
m_plugin = plugin;
m_messageBus = Locator.Current.GetService <IMessageBus>();
}
public SIMLHub() : base("SIMLHub")
{
bot = new SimlBot();
// Soon it will be substracted
adapterCount = 0;
// Add all adapters
pluginAdapterPathAndTypes = helper.GetAllSIMLHubPluginIndexAdapterPathAndTypes();
Console.ForegroundColor = ConsoleColor.Magenta;
Console.Write("[SIMLHub] Adapters loading : ");
Console.ResetColor();
simlPlugins = new List <AbstractPlugin>();
int botAdapterCount = 0;
foreach (var adapterPair in pluginAdapterPathAndTypes)
{
Assembly assembly = Assembly.LoadFrom(adapterPair.Key);
foreach (var typename in adapterPair.Value)
{
try
{
IAdapter adapter = (IAdapter)assembly.CreateInstance(typename);
AbstractPlugin simlHubPlugin = (AbstractPlugin)adapter;
simlPlugins.Add(simlHubPlugin);
Hub.PassThrough(simlHubPlugin.Hub);
// Add to bot in not null
if (adapter != null)
{
bot.Adapters.Add(adapter);
botAdapterCount++;
}
}
catch { /*Ignore*/ }
}
}
Console.ForegroundColor = ConsoleColor.Green;
Console.WriteLine("success");
Console.ResetColor();
// Now final value is set
adapterCount = botAdapterCount;
Console.WriteLine("[SIMLHub] SIMLHub Plugins count: " + adapterCount);
// Add all index.siml files
Console.ForegroundColor = ConsoleColor.Magenta;
Console.Write("[SIMLHub] Index siml merge : ");
Console.ResetColor();
string mergedIndexSimlPackage = helper.GetAllIndexSimlPackage();
Console.ForegroundColor = ConsoleColor.Green;
Console.WriteLine("success");
Console.ResetColor();
Console.ForegroundColor = ConsoleColor.Magenta;
Console.Write("[SIMLHub] Merged index siml : ");
Console.ResetColor();
bot.PackageManager.LoadFromString(mergedIndexSimlPackage);
Console.ForegroundColor = ConsoleColor.Green;
Console.WriteLine("success");
Console.ResetColor();
// Subscribe to IUserResponse for input
hub.Subscribe <IUserResponse>(GenerateAndPublishBotResponse);
hub.Subscribe <AllPluginsLoaded>(AllPluginsLoadedCallback);
// Subscribe to IMachineMessage for processing machine generated message
hub.Subscribe <IMachineMessage>(MakeMachineMessageUserFriendly);
}
public PluginLoadEventArgs(string pluginName, PluginLoadEventType pluginLoadEventType, AbstractPlugin plugin)
{
PluginName = pluginName;
EventType = pluginLoadEventType;
Plugin = plugin;
}
public static void AddPlugin(AbstractPlugin plugin)
{
logger.Debug("Registered plugin {0}", plugin.GetType());
Plugins.Add(plugin);
}
private void ConfigureContainer(IProgress <string> progress)
{
// use single logger for whole application
kernel.Bind <Logger>().ToSelf().InSingletonScope();
kernel.Get <Logger>();
Debug.WriteLine("Configuring application container...");
kernel.Bind <ISettings, Settings>().To <Settings>().InSingletonScope();
kernel.Bind <ISky, Sky>().To <Sky>().InSingletonScope();
kernel.Bind <ISkyMap, SkyMap>().To <SkyMap>().InSingletonScope();
kernel.Bind <SettingsConfig>().ToSelf().InSingletonScope();
kernel.Bind <ToolbarButtonsConfig>().ToSelf().InSingletonScope();
kernel.Bind <ContextMenuItemsConfig>().ToSelf().InSingletonScope();
SettingsConfig settingsConfig = kernel.Get <SettingsConfig>();
ToolbarButtonsConfig toolbarButtonsConfig = kernel.Get <ToolbarButtonsConfig>();
ContextMenuItemsConfig contextMenuItemsConfig = kernel.Get <ContextMenuItemsConfig>();
ICollection <AbstractPlugin> plugins = new List <AbstractPlugin>();
// TODO: consider more proper way to load plugins
string homeFolder = Path.GetDirectoryName(Assembly.GetEntryAssembly().Location);
IEnumerable <string> pluginPaths = Directory.EnumerateFiles(homeFolder, "*.dll");
progress.Report("Loading plugins");
foreach (string path in pluginPaths)
{
try
{
Assembly.LoadFrom(path);
}
catch (Exception ex)
{
Trace.TraceError($"Unable to load plugin assembly with path {path}. {ex})");
}
}
// collect all plugins implementations
// TODO: to support plugin system, we need to load assemblies
// from the specific directory and search for plugin there
Type[] pluginTypes = AppDomain.CurrentDomain.GetAssemblies()
.SelectMany(a => a.GetTypes())
.Where(t => typeof(AbstractPlugin).IsAssignableFrom(t) && !t.IsAbstract)
.ToArray();
// collect all calculators types
Type[] calcTypes = pluginTypes
.SelectMany(p => AbstractPlugin.Calculators(p))
.ToArray();
foreach (Type calcType in calcTypes)
{
var types = new[] { calcType }.Concat(calcType.GetInterfaces()).ToArray();
kernel.Bind(types).To(calcType).InSingletonScope();
}
// collect all renderers types
Type[] rendererTypes = pluginTypes
.SelectMany(p => AbstractPlugin.Renderers(p))
.ToArray();
foreach (Type rendererType in rendererTypes)
{
var types = new[] { rendererType }.Concat(rendererType.GetInterfaces()).ToArray();
kernel.Bind(rendererType).ToSelf().InSingletonScope();
}
// collect all event provider implementations
Type[] eventProviderTypes = pluginTypes
.SelectMany(p => AbstractPlugin.AstroEventProviders(p))
.ToArray();
foreach (Type eventProviderType in eventProviderTypes)
{
kernel.Bind(eventProviderType).ToSelf().InSingletonScope();
}
foreach (Type pluginType in pluginTypes)
{
progress.Report($"Creating plugin {pluginType}");
kernel.Bind(pluginType).ToSelf().InSingletonScope();
var plugin = kernel.Get(pluginType) as AbstractPlugin;
// add settings configurations
settingsConfig.AddRange(plugin.SettingItems);
// add configured toolbar buttons
toolbarButtonsConfig.AddRange(plugin.ToolbarItems);
// add configured context menu items
contextMenuItemsConfig.AddRange(plugin.ContextMenuItems);
plugins.Add(plugin);
}
// Default rendering order for BaseRenderer descendants.
settingsConfig.Add(new SettingItem("RenderingOrder", new RenderingOrder(), "Rendering", typeof(RenderersListSettingControl)));
var settings = kernel.Get <ISettings>();
// set settings defaults
foreach (SettingItem item in settingsConfig)
{
settings.Set(item.Name, item.DefaultValue);
}
settings.Save("Defaults");
progress.Report($"Loading settings");
settings.Load();
SetLanguage(settings.Get <string>("Language"));
SetColorSchema(settings.Get <ColorSchema>("Schema"));
SkyContext context = new SkyContext(
new Date(DateTime.Now).ToJulianEphemerisDay(),
new CrdsGeographical(settings.Get <CrdsGeographical>("ObserverLocation")));
progress.Report($"Creating calculators");
var calculators = calcTypes
.Select(c => kernel.Get(c))
.Cast <BaseCalc>()
.ToArray();
progress.Report($"Creating event providers");
var eventProviders = eventProviderTypes
.Select(c => kernel.Get(c))
.Cast <BaseAstroEventsProvider>()
.ToArray();
progress.Report($"Creating renderers");
var renderers = rendererTypes.Select(r => kernel.Get(r)).Cast <BaseRenderer>().ToArray();
kernel.Get <Sky>().Initialize(context, calculators, eventProviders);
kernel.Get <SkyMap>().Initialize(context, renderers);
Debug.Write("Application container has been configured.");
progress.Report($"Initializing shell");
settings.SettingValueChanged += (settingName, value) =>
{
if (settingName == "Schema")
{
SetColorSchema((ColorSchema)value);
}
else if (settingName == "Language")
{
SetLanguage((string)value);
}
};
}
public abstract void Save <T>(AbstractPlugin plugin, T obj) where T : class;