public AppViewModel(IPluginRepository pluginRepository,
IAccountSettingsProvider accounts,
IApplicationSettingsProvider applicationSettings,
IColumnsSettingsProvider columnsSettings,
Func<IPluginLoader> createPluginLoader,
Func<ResourcesViewModel> createResourceViewModel)
{
_pluginRepository = pluginRepository;
_accounts = accounts;
_applicationSettings = applicationSettings;
_columnsSettings = columnsSettings;
_loader = createPluginLoader();
Model = CompositionManager.Get<IMainViewModel>();
Resources = createResourceViewModel();
if (Model == null) return;
Model.FilterGroups = new ObservableCollection<StreamModel>(_columnsSettings.Filters);
if (Model.FilterGroups.Count != 0) return;
var f = StreamModel.CreateDefault();
Model.FilterGroups.Add(f);
}
/// <summary> Initializes plugin loaders, and attempts to load all plugins. </summary>
/// <exception cref="InvalidOperationException"> If PluginManager is already initialized. </exception>
public static void Init() {
if( initialized ) throw new InvalidOperationException( "PluginManager is already initialized." );
initialized = true;
PluginDescriptors = new Dictionary<string, PluginDescriptor>();
Plugins = new Dictionary<PluginDescriptor, IPlugin>();
cilPluginLoader = new CILPluginLoader();
string pythonPath = Path.Combine( Paths.WorkingPath, Paths.PythonPluginLoaderModule );
if( File.Exists( pythonPath ) ) {
Assembly pythonLoaderAsm = Assembly.LoadFile( pythonPath );
IPluginLoader pythonLoader = (IPluginLoader)pythonLoaderAsm.CreateInstance( PythonPluginLoaderType );
if( pythonLoader != null ) {
pythonPluginLoader = pythonLoader;
Logger.Log( LogType.Debug, "PluginManager: Python plugin support enabled." );
} else {
Logger.Log( LogType.Error, "PluginManager: Failed to load Python plugin support." );
}
}
DirectoryInfo pluginsDir = new DirectoryInfo( Paths.PluginDirectory );
if( pluginsDir.Exists ) {
foreach( FileInfo file in pluginsDir.EnumerateFiles( "*.fpi", SearchOption.AllDirectories ) ) {
LoadDescriptor( file.FullName );
}
if( PluginDescriptors.Count == 0 ) {
Logger.Log( LogType.Warning,
"PluginManager: No plugins found." );
}
} else {
Logger.Log( LogType.Warning,
"PluginManager: \"plugins\" directory missing." );
}
}
public PluginFactory(IFileSystem fileSystem, string pluginDirectory, IPluginLoader pluginLoader)
{
_fileSystem = fileSystem;
_pluginLoader = pluginLoader;
_pluginDirectory = string.IsNullOrWhiteSpace(pluginDirectory) ? Directory.GetCurrentDirectory() : pluginDirectory;
_pluginLoader.SetupDependencyResolver(_pluginDirectory);
_availablePlugins = new List<PluginMetadata>();
}
public DefaultPluginEngine(IFileSystem fs, IDataRepository repo, IMessageBus mbus, IMigrationRunner runner, IPluginLoader[] loaders)
{
_fs = fs;
_repo = repo;
_mbus = mbus;
_runner = runner;
_loaders = loaders;
}
public void Setup()
{
_messageDispatcher = new Fake_MessageDispatcher();
_pluginFactory = MockRepository.GenerateMock<IPluginLoader>();
_editor = MockRepository.GenerateMock<IEditor>();
_fileWriter = MockRepository.GenerateMock<IFileWriter>();
_dispatcher = new EditorDispatcher(_pluginFactory, _messageDispatcher, _fileWriter);
_dispatcher.SetEditor(_editor);
}
public static IPluginManager AddPlugins(this IServiceCollection services, IPluginLoader loader)
{
var pluginManager = new PluginManager(loader);
pluginManager.ConfigureServices(services);
services.Add(new ServiceDescriptor(typeof(IPluginManager), pluginManager));
services.AddPluginApplicationModel();
services.AddPluginViewLocations(pluginManager);
return pluginManager;
}
private void Initialize()
{
CustomXamlResourceLoader.Current = new LocalizingResourceLoader();
LocalizationHelper.Initialize();
DataViewModelOptions.AddNetworkExceptionType( typeof( WebException ) );
DataViewModelOptions.AddNetworkExceptionType( typeof( OperationCanceledException ) );
// ThinMVVM types
Container.Bind<ISettingsStorage, WindowsRuntimeSettingsStorage>();
Container.Bind<IDataCache, WindowsRuntimeDataCache>();
_navigationService = Container.Bind<IWindowsRuntimeNavigationService, WindowsRuntimeNavigationService>();
// Basic types
_pluginLoader = Container.Bind<IPluginLoader, PluginLoader>();
_settings = Container.Bind<IMainSettings, MainSettings>();
Container.Bind<IHttpClient, HttpClient>();
Container.Bind<IHttpHeaders, HttpHeaders>();
Container.Bind<IBrowserService, BrowserService>();
Container.Bind<IEmailService, EmailService>();
Container.Bind<IPhoneService, PhoneService>();
Container.Bind<ILocationService, LocationService>();
Container.Bind<ITileService, TileService>();
Container.Bind<IDeviceIdentifier, DeviceIdentifier>();
Container.Bind<IAppRatingService, AppRatingService>();
Container.Bind<ICredentialsStorage, CredentialsStorage>();
// Logger
Container.Bind<Logger, GoogleAnalyticsLogger>().Start();
// Types dependent on one of the above types
_serverAccess = Container.Bind<IServerAccess, ServerAccess>();
_protocolHandler = new ProtocolHandler( _pluginLoader, _navigationService );
// Views from Main
_navigationService.Bind<AboutViewModel, AboutView>();
_navigationService.Bind<MainViewModel, MainView>();
_navigationService.Bind<SettingsViewModel, SettingsView>();
// Register pocketcampus:// URIs to avoid going to the system and back when they're used inside of the app
LauncherEx.RegisterProtocol( ProtocolHandler.PocketCampusProtocol, _protocolHandler.NavigateToCustomUri );
// Initialize plugins, both their common part and their WinRT part
foreach ( var plugin in _pluginLoader.GetPlugins().Cast<IWindowsRuntimePlugin>() )
{
plugin.Initialize( (INavigationService) _navigationService );
plugin.Initialize( _navigationService );
}
// Handle the back button, since Windows Phone doesn't do it for us any more (unlike WP8 "Silverlight")
HardwareButtons.BackPressed += ( _, e ) =>
{
e.Handled = true;
_navigationService.NavigateBack();
};
}
/// <summary>
/// Creates the model loader
/// </summary>
/// <param name="suiteFactory">Factory interface to create new suite instances</param>
/// <param name="parametersLoaders">Parameter loader implementations</param>
/// <param name="output">Output interface to issue warnings</param>
/// <param name="pluginLoader">Plugin loader interface</param>
/// <param name="environmentVariableContext">Environment variable context</param>
/// <param name="suiteValidator">Suite validator interface</param>
public LocalYamlModelLoader(ISuiteFactory suiteFactory, IEnumerable<IYamlProjectParametersLoader> parametersLoaders, IUserOutput output, IPluginLoader pluginLoader, IEnvironmentVariableContext environmentVariableContext, ISuiteValidator suiteValidator)
: base(suiteFactory, parametersLoaders, output, pluginLoader, environmentVariableContext, suiteValidator)
{
Contract.Requires(suiteFactory != null);
Contract.Requires(output != null);
Contract.Requires(pluginLoader != null);
Contract.Requires(environmentVariableContext != null);
Contract.Requires(suiteValidator!= null);
}
private static PluginCatalog PopulateCatalog(IProgressMonitor progressMonitor,
IPluginLoader pluginLoader)
{
var pluginCatalog = new PluginCatalog();
using (var subProgressMonitor = progressMonitor.CreateSubProgressMonitor(45))
pluginLoader.PopulateCatalog(pluginCatalog, subProgressMonitor);
return pluginCatalog;
}
public DefaultPluginEngine(IFileSystem fileSystem,
IMessageBus messageBus,
IMigrationRunner migrationRunner,
IPluginLoader[] pluginLoaders)
{
_fileSystem = fileSystem;
_messageBus = messageBus;
_migrationRunner = migrationRunner;
_pluginLoaders = pluginLoaders;
}
private void OnPluginDisposed(object sender, EventArgs args)
{
--_refCount;
var plugin = sender as Plugin;
if (plugin != null) plugin.Disposed -= OnPluginDisposed;
if (_refCount == 0)
{
_pluginLoader.Terminate();
_pluginLoader = null;
_process = null;
}
}
private void OpenPluginLoader()
{
if (_pluginLoader != null) return;
if (!_readyEvent.WaitOne(5000))
{
throw new InvalidOperationException("Plugin host process not ready");
}
IpcChannelRegistration.RegisterChannel();
var url = "ipc://" + _name + "/PluginLoader";
_pluginLoader = (IPluginLoader)Activator.GetObject(typeof(IPluginLoader), url);
}
public static void Initialize( IPluginLoader pluginLoader, INavigationService navigationService )
{
DataViewModelOptions.AddNetworkExceptionType( typeof( WebException ) );
DataViewModelOptions.AddNetworkExceptionType( typeof( OperationCanceledException ) );
Container.Bind<IMainSettings, MainSettings>();
Container.Bind<IServerAccess, ServerAccess>();
foreach ( var plugin in pluginLoader.GetPlugins() )
{
plugin.Initialize( navigationService );
}
// SecureRequestHandler depends on the auth plugin, so it must be initialized after it
Container.Bind<ISecureRequestHandler, SecureRequestHandler>();
}
public PluginManagementService(
ILogger logger,
IRestClient restClient,
IPluginInstaller pluginInstaller,
IPluginLoader pluginLoader,
IPluginHttpApi pluginHttpApi)
{
_logger = logger;
_restClient = restClient;
_pluginInstaller = pluginInstaller;
_pluginLoader = pluginLoader;
_pluginHttpApi = pluginHttpApi;
_serverPort = TcpHelper.GetFreePort();
_pluginApiUri = new Uri($"http://127.0.0.1:{_serverPort}/");
}
/// <summary>
/// Creates a new App.
/// </summary>
public App()
{
InitializeComponent();
// Services
_navigationService = Container.Bind<IWindowsPhoneNavigationService, WindowsPhoneNavigationService>();
Container.Bind<ISettingsStorage, WindowsPhoneSettingsStorage>();
Container.Bind<IHttpClient, HttpClient>();
Container.Bind<IBrowserService, BrowserService>();
Container.Bind<IEmailService, EmailService>();
Container.Bind<IPhoneService, PhoneService>();
Container.Bind<ILocationService, LocationService>();
Container.Bind<ITileService, TileService>();
Container.Bind<IDeviceIdentifier, DeviceIdentifier>();
Container.Bind<IRatingService, RatingService>();
Container.Bind<IDataCache, WindowsPhoneDataCache>();
Container.Bind<ICredentialsStorage, WindowsPhoneCredentialsStorage>();
_pluginLoader = Container.Bind<IPluginLoader, PluginLoader>();
_logger = Container.Bind<Logger, GoogleAnalyticsLogger>();
// Common part of plugins & services initialization
AppInitializer.Initialize( _pluginLoader, _navigationService );
// View-ViewModels bindings for Main
_navigationService.Bind<MainViewModel>( "/Views/MainView.xaml" );
_navigationService.Bind<SettingsViewModel>( "/Views/SettingsView.xaml" );
_navigationService.Bind<AboutViewModel>( "/Views/AboutView.xaml" );
// URI mapping
LauncherEx.RegisterProtocol( PocketCampusProtocol, NavigateToCustomUri );
// WP-specific part of plugin initialization
_plugins = _pluginLoader.GetPlugins().Cast<IWindowsPhonePlugin>().ToArray();
foreach ( var plugin in _plugins )
{
plugin.Initialize( _navigationService );
}
// Debug settings
DebugSettings.UserIdleDetectionMode = IdleDetectionMode.Disabled;
// Theme initialization
ThemeManager.OverrideOptions = ThemeManagerOverrideOptions.ApplicationBarColors;
ThemeManager.ToLightTheme();
ThemeManager.SetAccentColor( (Color) Resources["AppAccentColor"] );
}
/// <summary>
/// Initializes the yaml loader
/// </summary>
/// <param name="suiteFactory">Factory interface to create new suite instances</param>
/// <param name="parametersLoaders">Parameter loader implementations</param>
/// <param name="output">Output interface to issue warnings</param>
/// <param name="pluginLoader">Plugin loader interface</param>
/// <param name="environmentVariableContext">Environment variable context</param>
/// <param name="validator">Suite validator interface</param>
protected YamlModelLoaderBase(ISuiteFactory suiteFactory, IEnumerable<IYamlProjectParametersLoader> parametersLoaders, IUserOutput output, IPluginLoader pluginLoader, IEnvironmentVariableContext environmentVariableContext, ISuiteValidator validator)
{
Contract.Requires(suiteFactory != null);
Contract.Requires(output != null);
Contract.Requires(pluginLoader != null);
Contract.Requires(environmentVariableContext != null);
Contract.Requires(validator != null);
Contract.Ensures(this.suiteFactory == suiteFactory);
Contract.Ensures(this.parametersLoaders == parametersLoaders);
this.suiteFactory = suiteFactory;
this.parametersLoaders = parametersLoaders;
this.output = output;
this.pluginLoader = pluginLoader;
this.validator = validator;
versioningEnvironmentVariableContext = new VersioningEnvironmentVariableContext(environmentVariableContext);
parser = new YamlParser();
}
/// <summary>
/// Initializes the runtime.
/// </summary>
/// <param name="registry">The registry.</param>
/// <param name="pluginLoader">The plugin loader.</param>
/// <param name="assemblyLoader">The assembly loader.</param>
/// <param name="runtimeSetup">The runtime setup options.</param>
/// <exception cref="ArgumentNullException">Thrown if <paramref name="registry"/>,
/// <paramref name="pluginLoader"/>, <paramref name="assemblyLoader"/> or
/// <paramref name="runtimeSetup" /> is null.</exception>
public DefaultRuntime(IRegistry registry, IPluginLoader pluginLoader,
IAssemblyLoader assemblyLoader, RuntimeSetup runtimeSetup)
{
if (registry == null)
throw new ArgumentNullException("registry");
if (pluginLoader == null)
throw new ArgumentNullException("pluginLoader");
if (assemblyLoader == null)
throw new ArgumentNullException(@"assemblyResolverManager");
if (runtimeSetup == null)
throw new ArgumentNullException(@"runtimeSetup");
this.registry = registry;
this.pluginLoader = pluginLoader;
this.assemblyLoader = assemblyLoader;
this.runtimeSetup = runtimeSetup.Copy();
dispatchLogger = new DispatchLogger();
pluginDirectories = new List<string>();
conditionContext = new RuntimeConditionContext();
}
internal DefaultPluginManager(PluginInfo info, IMessageBus mbus, IMigrationRunner runner, IPluginLoader[] loaders)
{
_info = info;
_mbus = mbus;
_runner = runner;
_loaders = loaders;
var loader = (from l in _loaders
where l.CanLoad(_info.Path)
select l).First();
if (loader != null)
{
_pluginType = loader.Load(_info.Path).First();
if (_pluginType == null)
{
throw new ArgumentException("Could not find plugin type in given PluginInfo.Path", "info");
}
}
}
protected PluginEvent(IPluginLoader pluginLoader, IPlugin plugin) : this(pluginLoader, plugin, true)
{
}
public ProtocolHandler( IPluginLoader pluginLoader, INavigationService navigationService )
{
_plugins = pluginLoader.GetPlugins();
_navigationService = navigationService;
}
private static void ConfigureRazor(RazorViewEngineOptions options, IHostingEnvironment hostingEnvironment, IPluginLoader loader)
{
if (hostingEnvironment.IsDevelopment())
{
options.FileProviders.Add(new DeveloperViewFileProvider());
}
loader.GetPluginAssemblies().Each(assembly =>
{
var reference = MetadataReference.CreateFromFile(assembly.Location);
options.AdditionalCompilationReferences.Add(reference);
});
//options.CompilationCallback = context =>
//{
// var reference = MetadataReference.CreateFromFile(@"D:\Projects\ZKEACMS.Core\src\TestAss\bin\Debug\netstandard1.6\TestAss.dll");
// context.Compilation = context.Compilation.AddReferences(reference);
//};
loader.GetPlugins().Where(m => m.Enable && m.ID.IsNotNullAndWhiteSpace()).Each(m =>
{
var directory = new DirectoryInfo(m.RelativePath);
if (hostingEnvironment.IsDevelopment())
{
options.ViewLocationFormats.Add($"/Porject.RootPath/{directory.Name}" + "/Views/{1}/{0}" + RazorViewEngine.ViewExtension);
options.ViewLocationFormats.Add($"/Porject.RootPath/{directory.Name}" + "/Views/Shared/{0}" + RazorViewEngine.ViewExtension);
options.ViewLocationFormats.Add($"/Porject.RootPath/{directory.Name}" + "/Views/{0}" + RazorViewEngine.ViewExtension);
}
else
{
options.ViewLocationFormats.Add($"/wwwroot/{Loader.PluginFolder}/{directory.Name}" + "/Views/{1}/{0}" + RazorViewEngine.ViewExtension);
options.ViewLocationFormats.Add($"/wwwroot/{Loader.PluginFolder}/{directory.Name}" + "/Views/Shared/{0}" + RazorViewEngine.ViewExtension);
options.ViewLocationFormats.Add($"/wwwroot/{Loader.PluginFolder}/{directory.Name}" + "/Views/{0}" + RazorViewEngine.ViewExtension);
}
});
options.ViewLocationFormats.Add("/Views/{0}" + RazorViewEngine.ViewExtension);
}
/// <summary>
/// Initializes a new instance of the <see cref="HistoryStorageFactory" /> class.
/// </summary>
/// <param name="pluginLoader">The plugin loader.</param>
public HistoryStorageFactory(IPluginLoader pluginLoader)
{
this.pluginLoader = pluginLoader ?? throw new ArgumentNullException(nameof(pluginLoader));
}
public void LoadPlugin()
{
if (Process == null) throw new InvalidOperationException("Plugin process not started");
if (Process.HasExited) throw new InvalidOperationException("Plugin process has terminated unexpectedly");
_pluginLoader = GetPluginLoader();
RemotePlugin = _pluginLoader.LoadPlugin(_host, _startupInfo);
}
/// <summary>
/// Initializes a new instance of the <see cref="ReportBuilderFactory" /> class.
/// </summary>
/// <param name="pluginLoader">The plugin loader.</param>
public ReportBuilderFactory(IPluginLoader pluginLoader)
{
this.pluginLoader = pluginLoader ?? throw new ArgumentNullException(nameof(pluginLoader));
}
/// <summary>Initializes a new instance of the <see cref="PluginDockManagerService"/> class.</summary>
/// <param name="pluginLoader">The plug-in loader.</param>
public PluginDockManagerService(IPluginLoader pluginLoader)
{
PluginLoader = pluginLoader;
}
private static void LoadConfigurationData(XmlElement gallioElement, IPluginLoader pluginLoader, DirectoryInfo baseDirectory)
{
foreach (XmlElement pluginElement in gallioElement.GetElementsByTagName("plugin", SchemaConstants.XmlNamespace))
pluginLoader.AddPluginXml(pluginElement.OuterXml, baseDirectory);
}
public LazyHelloController(IPluginLoader <IHelloPlugin> pluginLoader)
{
_pluginLoader = pluginLoader;
}
public static void SendCommand(this IPluginLoader pluginLoader, MahuaCommand command)
{
pluginLoader.Handle(GlobalCache.JavaScriptSerializer.Serialize(command),
command.GetType().FullName);
}
public PluginCache(IPluginLoader pluginLoader)
{
_pluginLoader = pluginLoader ?? throw new ArgumentNullException(nameof(pluginLoader));
_loadedPlugins = new Dictionary <Type, IReadOnlyList <IPlugin> >();
}
static PluginFactory()
{
PluginFactory._syncObject = new object();
PluginFactory.container = new PluginContainer();
PluginFactory.loader = new PluginLoader(PluginFactory.container);
}
public LazyCalculationController(ILogger <LazyCalculationController> logger, IPluginLoader <ICalculationPlugin> loader)
{
_logger = logger;
_loader = loader;
}
public PluginCache(IPluginLoader pluginLoader)
{
_syncRoot = new object();
_pluginLoader = pluginLoader ?? throw new ArgumentNullException(nameof(pluginLoader));
_loadedPlugins = new Dictionary <Type, IReadOnlyList <IPluginWithDescription <IPlugin> > >();
}
public TileService( IPluginLoader pluginLoader )
{
_pluginLoader = pluginLoader;
}
protected PluginEvent(IPluginLoader pluginLoader, IPlugin plugin, bool global = true) : base(global)
{
PluginLoader = pluginLoader;
Plugin = plugin;
}
public PluginActivateEvent(IPluginLoader pluginLoader, IPlugin plugin) : base(pluginLoader, plugin)
{
}
public PluginStaticFileMiddleware(RequestDelegate next, IHostingEnvironment hostingEnv, IOptions <StaticFileOptions> options, IPluginLoader pluginLoader)
{
_next = next;
_contentTypeProvider = options.Value.ContentTypeProvider ?? new FileExtensionContentTypeProvider();
_pluginLoader = pluginLoader;
_hostingEnvironment = hostingEnv;
}
// Multiple instances of plugins can be loaded using the IPluginLoader
public MultipleLazyCalculationController(ILogger <MultipleLazyCalculationController> logger, IPluginLoader <ICalculationPlugin> pluginLoader)
{
_logger = logger;
_pluginLoader = pluginLoader;
}
public SectionGroupService(ISectionContentProviderService sectionContentProviderService,
IPluginLoader pluginLoader, IApplicationContext applicationContext) : base(applicationContext)
{
_sectionContentProviderService = sectionContentProviderService;
_pluginLoader = pluginLoader;
}
/// <summary>
/// Initializes a new instance of the <see cref="PluginContainer"/> class.
/// </summary>
/// <param name="host">The host.</param>
public PluginContainer(IPluginHost host, IPluginLoader loader)
{
PluginContext.Host = host;
this.loader = loader;
this.Plugins = new List<IPlugin>();
}
/// <summary>
/// Initializes a new instance of the <see cref="PluginHandler"/> class.
/// </summary>
/// <param name="pluginLoader">The plugin loader.</param>
/// <param name="authorizer">The authorizer.</param>
/// <param name="serviceFactory">The service factory.</param>
public PluginHandler(IPluginLoader pluginLoader, IAuthorization authorizer, IServiceHostFactory serviceFactory)
{
Guard.Against(pluginLoader == null, "pluginLoader");
Guard.Against(authorizer == null, "authorizer");
Guard.Against(serviceFactory == null, "serviceFactory");
this.pluginDirectory = pluginLoader.PluginDirectory;
this.pluginLoader = pluginLoader;
this.authorizer = authorizer;
this.serviceFactory = serviceFactory;
}
public PluginManagerModel(IPluginLoader pluginLoader)
{
_pluginLoader = pluginLoader;
_actionPlugins = new Dictionary<Guid, IActionPluginDetails>();
}
public PluginRazorViewEngineOptionsSetup(IHostingEnvironment hostingEnvironment, IPluginLoader loader) :
base(options =>
{
if (hostingEnvironment.IsDevelopment())
{
options.FileProviders.Add(new DeveloperViewFileProvider(hostingEnvironment));
}
options.AllowRecompilingViewsOnFileChange = true;
options.ViewLocationFormats.Clear();
loader.GetPlugins().Where(m => m.Enable && m.ID.IsNotNullAndWhiteSpace()).Each(m =>
{
var directory = new DirectoryInfo(m.RelativePath);
if (hostingEnvironment.IsDevelopment())
{
options.ViewLocationFormats.Add($"{DeveloperViewFileProvider.ProjectRootPath}{directory.Name}" + "/Views/{0}" + RazorViewEngine.ViewExtension);
options.ViewLocationFormats.Add($"{DeveloperViewFileProvider.ProjectRootPath}{directory.Name}" + "/Views/{1}/{0}" + RazorViewEngine.ViewExtension);
options.ViewLocationFormats.Add($"{DeveloperViewFileProvider.ProjectRootPath}{directory.Name}" + "/Views/Shared/{0}" + RazorViewEngine.ViewExtension);
}
else
{
options.ViewLocationFormats.Add($"/wwwroot/{Loader.PluginFolder}/{directory.Name}" + "/Views/{0}" + RazorViewEngine.ViewExtension);
options.ViewLocationFormats.Add($"/wwwroot/{Loader.PluginFolder}/{directory.Name}" + "/Views/{1}/{0}" + RazorViewEngine.ViewExtension);
options.ViewLocationFormats.Add($"/wwwroot/{Loader.PluginFolder}/{directory.Name}" + "/Views/Shared/{0}" + RazorViewEngine.ViewExtension);
}
});
options.ViewLocationFormats.Add("/Views/{0}" + RazorViewEngine.ViewExtension);
options.ViewLocationFormats.Add("/Views/{1}/{0}.cshtml");
options.ViewLocationFormats.Add("/Views/Shared/{0}.cshtml");
})
{
}
/// <summary>Initializes a new instance of the <see cref="PluginDockManagerService"/> class.</summary>
/// <param name="pluginDirectory">The plug-in directory.</param>
public PluginDockManagerService(string pluginDirectory)
{
PluginLoader = new PluginLoader(pluginDirectory);
}
public PluginManagerInitEvent(IPluginLoader pluginLoader,
EventExecutionTargetContext executionTarget = EventExecutionTargetContext.Sync,
bool global = true) : base(executionTarget, global)
{
PluginLoader = pluginLoader;
}
/// <summary>
/// Initializes this DualityApp. Should be called before performing any operations within Duality.
/// </summary>
/// <param name="context">The <see cref="ExecutionContext"/> in which Duality runs.</param>
/// <param name="commandLineArgs">
/// Command line arguments to run this DualityApp with.
/// Usually these are just the ones from the host application, passed on.
/// </param>
public static void Init(ExecutionEnvironment env, ExecutionContext context, IPluginLoader plugins, string[] commandLineArgs)
{
if (initialized)
{
return;
}
// Process command line options
if (commandLineArgs != null)
{
// Enter debug mode
if (commandLineArgs.Contains(CmdArgDebug))
{
System.Diagnostics.Debugger.Launch();
}
// Run from editor
if (commandLineArgs.Contains(CmdArgEditor))
{
runFromEditor = true;
}
}
environment = env;
execContext = context;
// Initialize the plugin manager
{
pluginLoader = plugins ?? new Duality.Backend.Dummy.DummyPluginLoader();
Log.Core.Write("Using '{0}' to load plugins.", pluginLoader.GetType().Name);
pluginLoader.Init();
// Log assembly loading data for diagnostic purposes
{
Log.Core.Write("Currently Loaded Assemblies:" + Environment.NewLine + "{0}",
pluginLoader.LoadedAssemblies.ToString(
assembly => " " + Log.Assembly(assembly),
Environment.NewLine));
Log.Core.Write("Plugin Base Directories:" + Environment.NewLine + "{0}",
pluginLoader.BaseDirectories.ToString(
path => " " + path,
Environment.NewLine));
Log.Core.Write("Available Assembly Paths:" + Environment.NewLine + "{0}",
pluginLoader.AvailableAssemblyPaths.ToString(
path => " " + path,
Environment.NewLine));
}
pluginManager.Init(pluginLoader);
pluginManager.PluginsReady += pluginManager_PluginsReady;
pluginManager.PluginsRemoving += pluginManager_PluginsRemoving;
pluginManager.PluginsRemoved += pluginManager_PluginsRemoved;
}
// Load all plugins. This needs to be done first, so backends and Types can be located.
pluginManager.LoadPlugins();
// Initialize the system backend for system info and file system access
InitBackend(out systemBack);
// Load application and user data and submit a change event, so all settings are applied
LoadAppData();
LoadUserData();
OnAppDataChanged();
OnUserDataChanged();
// Initialize the graphics backend
InitBackend(out graphicsBack);
// Initialize the audio backend
InitBackend(out audioBack);
sound = new SoundDevice();
// Initialize all core plugins, this may allocate Resources or establish references between plugins
pluginManager.InitPlugins();
initialized = true;
// Write environment specs as a debug log
Log.Core.Write(
"DualityApp initialized" + Environment.NewLine +
"Debug Mode: {0}" + Environment.NewLine +
"Command line arguments: {1}",
System.Diagnostics.Debugger.IsAttached,
commandLineArgs != null ? commandLineArgs.ToString(", ") : "null");
}
public PluginManagerInitEvent(IPluginLoader pluginLoader) : this(pluginLoader, true)
{
PluginLoader = pluginLoader;
}
public PluginRazorViewEngineOptionsSetup(IHostingEnvironment hostingEnvironment, IPluginLoader loader) :
base(options => ConfigureRazor(options, hostingEnvironment, loader))
{
}
public void Register()
{
_thePlugin = this;
_folderWatchers = new HashMap();
_dbLocations = new HashSet();
_icqContacts = new ArrayList();
_icqMessages = new ArrayList();
_idResources = new IntHashSet();
RegisterTypes();
IUIManager uiMgr = Core.UIManager;
uiMgr.RegisterOptionsGroup("Instant Messaging", "The Instant Messaging options enable you to control how [product name] works with supported instant messaging programs.");
OptionsPaneCreator icqPaneCreator = ICQOptionsPane.ICQOptionsPaneCreator;
uiMgr.RegisterOptionsPane("Instant Messaging", "ICQ", icqPaneCreator,
"The ICQ options enable you to specify which ICQ accounts should be indexed, and how [product name] should build conversations from ICQ messages.");
uiMgr.AddOptionsChangesListener("Instant Messaging", "ICQ", ICQOptionsChanged);
if (UINsCollection.GetUINs().Count > 0)
{
uiMgr.RegisterWizardPane("ICQ", icqPaneCreator, 10);
Core.TabManager.RegisterResourceTypeTab("IM", "IM", _icqConversationResName, 2);
_correspondentPane = new CorrespondentCtrl();
_correspondentPane.IniSection = "ICQ";
_correspondentPane.SetCorresponentFilterList(Core.ResourceStore.FindResourcesWithProp(null, "ICQAcct"));
Image img = Utils.TryGetEmbeddedResourceImageFromAssembly(Assembly.GetExecutingAssembly(), "ICQPlugin.Icons.Correspondents24.png");
Core.LeftSidebar.RegisterResourceStructurePane("ICQCorrespondents", "IM", "ICQ Correspondents", img, _correspondentPane);
Core.LeftSidebar.RegisterViewPaneShortcut("ICQCorrespondents", Keys.Control | Keys.Alt | Keys.Q);
}
IPluginLoader loader = Core.PluginLoader;
IActionManager actionManager = Core.ActionManager;
loader.RegisterResourceDisplayer(_icqConversationResName, this);
actionManager.RegisterLinkClickAction(new ConversationLinkClickAction(), _icqConversationResName, null);
_conversationManager = new IMConversationsManager(_icqConversationResName, "ICQ Conversation", "Subject",
GetConversationTimeSpan(), _propICQAcct, _propFromICQ, _propToICQ, this);
_conversationManager.ReverseMode = GetReverseMode();
SaveConversationAction saveConvAction = new SaveConversationAction(_conversationManager, _propNickName);
actionManager.RegisterContextMenuAction(saveConvAction, ActionGroups.ITEM_OPEN_ACTIONS, ListAnchor.Last,
"Save to File...", null, _icqConversationResName, null);
actionManager.RegisterActionComponent(saveConvAction, "SaveAs", _icqConversationResName, null);
EmailConversationAction mailConvAction = new EmailConversationAction(_conversationManager, _propNickName);
actionManager.RegisterContextMenuAction(mailConvAction, ActionGroups.ITEM_OPEN_ACTIONS, ListAnchor.Last,
"Send by Email", null, _icqConversationResName, null);
actionManager.RegisterActionComponent(mailConvAction, "SendByMail", _icqConversationResName, null);
loader.RegisterResourceSerializer(_icqAccountResName, new ICQAccountSerializer());
loader.RegisterResourceTextProvider(_icqConversationResName, _conversationManager);
loader.RegisterResourceTextProvider(_contactResName, this);
Core.ResourceBrowser.RegisterLinksPaneFilter(_icqConversationResName, new ItemRecipientsFilter());
Core.ResourceBrowser.RegisterLinksGroup("Accounts", new[] { _propICQAcct }, ListAnchor.First);
// Upgrade information about ICQ address book - set its
// ContentType property so that it could be filtered out when
// this plugin is switched off.
IResource ab = Core.ResourceStore.FindUniqueResource("AddessBook", "Name", "ICQ Contacts");
if (ab != null)
{
ab.SetProp("ContentType", _icqConversationResName);
}
Core.ResourceBrowser.SetDefaultViewSettings("IM", AutoPreviewMode.Off, true);
}
public PluginManager(IPluginLoader loader)
{
if (loader == null)
throw new ArgumentNullException(nameof(loader));
_loader = loader;
}
public PluginUpdater(IPluginLoader pluginLoader)
{
_pluginLoader = pluginLoader;
}
public PluginActivateEvent(IPluginLoader pluginLoader, IPlugin plugin, bool global = true) : base(
pluginLoader,
plugin, global)
{
}
public PluginActivateEvent(IPluginLoader pluginLoader, IPlugin plugin,
EventExecutionTargetContext executionTarget = EventExecutionTargetContext.Sync,
bool global = true) : base(pluginLoader, plugin, executionTarget, global)
{
}
private static IReadOnlyDictionary <AnalyserPluginId, IWidgetPlugin> LoadRelevantPlugins(IPluginLoader pluginLoader)
{
var plugins = pluginLoader.LoadAllOfType <IWidgetPlugin>();
var pluginsById = new Dictionary <AnalyserPluginId, IWidgetPlugin>(plugins.Count);
foreach (var plugin in plugins)
{
if (!pluginsById.TryGetValue(plugin.AnalyserId, out var existingPlugin))
{
pluginsById.Add(plugin.AnalyserId, plugin);
}
else
{
Log.WarnFormat("Ignoring plugin {0} with id {1}, there already is another plugin registered with the same id: {2}",
plugin.GetType(),
plugin.AnalyserId,
existingPlugin.GetType());
}
}
return(pluginsById);
}
/// <summary>
/// Initializes the yaml loader
/// </summary>
/// <param name="suiteFactory">Factory interface to create new suite instances</param>
/// <param name="parametersLoaders">Parameter loader implementations</param>
/// <param name="output">Output interface to issue warnings</param>
/// <param name="pluginLoader">Plugin loader interface</param>
/// <param name="environmentVariableContext">Environment variable context</param>
/// <param name="validator">Suite validator interface</param>
protected YamlModelLoaderBase(ISuiteFactory suiteFactory, IEnumerable <IYamlProjectParametersLoader> parametersLoaders, IUserOutput output, IPluginLoader pluginLoader, IEnvironmentVariableContext environmentVariableContext, ISuiteValidator validator)
{
Contract.Requires(suiteFactory != null);
Contract.Requires(output != null);
Contract.Requires(pluginLoader != null);
Contract.Requires(environmentVariableContext != null);
Contract.Requires(validator != null);
Contract.Ensures(this.suiteFactory == suiteFactory);
Contract.Ensures(this.parametersLoaders == parametersLoaders);
this.suiteFactory = suiteFactory;
this.parametersLoaders = parametersLoaders;
this.output = output;
this.pluginLoader = pluginLoader;
this.validator = validator;
versioningEnvironmentVariableContext = new VersioningEnvironmentVariableContext(environmentVariableContext);
parser = new YamlParser();
}
public PluginManagerInitEvent(IPluginLoader pluginLoader, bool global = true) : base(global)
{
PluginLoader = pluginLoader;
}
public DiscoveryController(ILogger <DiscoveryController> logger, IPluginLoader <ICalculationPlugin> loader)
{
_logger = logger;
_loader = loader;
}
