protected override IEnumerable <object> DoGetAllInstances(Type serviceType)
{
if (serviceType is null)
{
throw new ArgumentNullException(nameof(serviceType));
}
if (disposedValue)
{
return(Enumerable.Empty <object>());
}
return(_container?.GetExports(serviceType, null, null)?.Select(e => e.Value) ?? Enumerable.Empty <object>());
}
public static void OpenApplicationSettingsWindow(CompositionContainer container)
{
Messenger <MessengerMessages> .Register(MessengerMessages.OpenApplicationSettings, (args) =>
{
var view = container?.GetExports <ViewApplicationSettings>().Single().Value;
view.ShowDialog();
});
}
public static void ProcessFilePaths(CompositionContainer container)
{
Messenger <MessengerMessages> .Register(MessengerMessages.ProcessFilePaths, async (args) =>
{
var vm = container?.GetExports <MainViewModel>().Single().Value;
await vm.ProcessFilePathsAsync(args as IEnumerable <string>);
});
}
public static void OpenMediaPlayerMainWindow(CompositionContainer container)
{
Messenger <MessengerMessages> .Register(MessengerMessages.OpenMediaPlayerMainWindow, (args) =>
{
var view = container?.GetExports <ViewMediaPlayer>().Single().Value;
view.Show();
});
}
public static void SaveChangesToDirtyFiles(CompositionContainer container)
{
Messenger <MessengerMessages> .Register(MessengerMessages.SaveChangesToDirtyFiles, async (args) =>
{
var vm = container?.GetExports <MainViewModel>().Single().Value;
await vm.SaveChangesAsync();
var shutdownApplication = (bool)args;
if (shutdownApplication)
{
Application.Current.Shutdown(0);
}
});
}
public void Invoke(CompositionContainer container)
{
var traceListener = new ConsolidatedConsoleTraceListener(
new Dictionary <string, string>
{
{
"LostDoc.Core.Template",
"Template"
},
{
"LostDoc.Core.Bundle",
"Bundle"
},
{
"LostDoc.Core.Template.AssetResolver",
"Resolve"
}
});
TraceSources.TemplateSource.Listeners.Add(traceListener);
TraceSources.AssetResolverSource.Listeners.Add(traceListener);
try
{
if (this.Quiet.IsPresent)
{
const SourceLevels quietLevel = SourceLevels.Error | SourceLevels.Warning | SourceLevels.Critical;
TraceSources.TemplateSource.Switch.Level = quietLevel;
TraceSources.AssetResolverSource.Switch.Level = quietLevel;
TraceSources.BundleSource.Listeners.Add(traceListener);
}
else if (this.Verbose.IsPresent)
{
const SourceLevels verboseLevel = SourceLevels.All;
TraceSources.TemplateSource.Switch.Level = verboseLevel;
TraceSources.AssetResolverSource.Switch.Level = verboseLevel;
TraceSources.BundleSource.Listeners.Add(traceListener);
}
else
{
const SourceLevels normalLevel = SourceLevels.Information | SourceLevels.Warning | SourceLevels.Error | SourceLevels.ActivityTracing;
TraceSources.TemplateSource.Switch.Level = normalLevel;
TraceSources.AssetResolverSource.Switch.Level = normalLevel;
}
LinkedList <FileInfo> includedFiles = new LinkedList <FileInfo>();
if (File.Exists(this.Path))
{
includedFiles.AddLast(new FileInfo(this.Path));
}
else if (Directory.Exists(this.Path))
{
Directory.GetFiles(this.Path, "*.ldoc", SearchOption.AllDirectories)
.Aggregate(includedFiles,
(l, f) => l.AddLast(new FileInfo(f)).List);
}
else
{
throw new FileNotFoundException(System.IO.Path.GetFullPath(this.Path));
}
Bundle bundle = new Bundle(this.IgnoreVersionComponent);
TraceSources.TemplateSource.TraceInformation("Merging LostDoc files into bundle.");
foreach (FileInfo file in includedFiles)
{
TraceSources.TemplateSource.TraceEvent(TraceEventType.Information, 0, "Source: {0}", file.Name);
XDocument fileDoc = XDocument.Load(file.FullName);
bundle.Add(fileDoc);
}
var lazyProviders = container.GetExports <IFileProvider>(ContractNames.TemplateProvider);
var realProviders = lazyProviders.Select(lazy => lazy.Value);
TemplateResolver templateResolver = new TemplateResolver(realProviders.ToArray());
Template template = new Template(container);
template.Load(templateResolver, this.Template);
string outputDir = this.Output
?? (Directory.Exists(this.Path)
? this.Path
: System.IO.Path.GetDirectoryName(this.Path));
AssetRedirectCollection assetRedirects;
XDocument mergedDoc = bundle.Merge(out assetRedirects);
var templateData = new TemplateData(mergedDoc)
{
AssetRedirects = assetRedirects,
OverwriteExistingFiles = this.Force.IsPresent,
IgnoredVersionComponent = this.IgnoreVersionComponent,
Arguments = this.Arguments,
OutputFileProvider = new ScopedFileProvider(new DirectoryFileProvider(), outputDir)
};
template.Generate(templateData);
}
finally
{
TraceSources.TemplateSource.Listeners.Remove(traceListener);
TraceSources.AssetResolverSource.Listeners.Remove(traceListener);
}
}
private MockVsTextView CreateTextViewWorker(
string contentType,
string content,
Action <MockVsTextView> onCreate,
string file = null
)
{
var buffer = new MockTextBuffer(content, ContentTypeRegistry.GetContentType(contentType), file);
var view = new MockTextView(buffer);
var res = new MockVsTextView(_serviceProvider, this, view);
view.Properties[typeof(MockVsTextView)] = res;
onCreate?.Invoke(res);
var classifier = res.Classifier;
if (classifier != null)
{
classifier.GetClassificationSpans(new SnapshotSpan(buffer.CurrentSnapshot, 0, buffer.CurrentSnapshot.Length));
}
// Initialize code window
LanguageServiceInfo info;
if (CachedInfo.LangServicesByName.TryGetValue(contentType, out info))
{
var id = info.Attribute.LanguageServiceSid;
var serviceProvider = Container.GetExportedValue <MockVsServiceProvider>();
var langInfo = (IVsLanguageInfo)serviceProvider.GetService(id);
if (langInfo == null)
{
throw new NotImplementedException("Unable to get IVsLanguageInfo for " + info.Attribute.LanguageName);
}
IVsCodeWindowManager mgr;
var codeWindow = new MockCodeWindow(serviceProvider, view);
view.Properties[typeof(MockCodeWindow)] = codeWindow;
if (ErrorHandler.Succeeded(langInfo.GetCodeWindowManager(codeWindow, out mgr)))
{
if (ErrorHandler.Failed(mgr.AddAdornments()))
{
Console.WriteLine("Failed to add adornments to text view");
}
}
}
// Initialize intellisense imports
var providers = Container.GetExports <IIntellisenseControllerProvider, IContentTypeMetadata>();
foreach (var provider in providers)
{
foreach (var targetContentType in provider.Metadata.ContentTypes)
{
if (buffer.ContentType.IsOfType(targetContentType))
{
provider.Value.TryCreateIntellisenseController(
view,
new[] { buffer }
);
break;
}
}
}
// tell the world we have a new view...
foreach (var listener in Container.GetExports <IVsTextViewCreationListener, IContentTypeMetadata>())
{
foreach (var targetContentType in listener.Metadata.ContentTypes)
{
if (buffer.ContentType.IsOfType(targetContentType))
{
listener.Value.VsTextViewCreated(res);
}
}
}
OnDispose(() => res.Close());
return(res);
}
static void Main(string[] args)
{
if (args.Length < 0)
{
// click once argument data
args = AppDomain.CurrentDomain.SetupInformation.ActivationArguments.ActivationData;
}
var reset = false;
if (args.Length <= 0)
{
System.Console.Write("R for RESET, Any other key to READ A FILE... ");
var keyInfo = System.Console.ReadKey(true);
reset = keyInfo.Key == ConsoleKey.R;
System.Console.WriteLine();
}
if (reset || (args.Length > 0 && args[0] == "RESET"))
{
ResetSettings();
}
else
{
var connection = Authenticate();
Interaction.Notice("USER: "******"HOST: " + Properties.Settings.Default.Host + ":" + Properties.Settings.Default.Port);
FileInfo inputFile = null;
if (args.Length >= 1)
{
inputFile = new FileInfo(args[0]);
}
else
{
var inputFileName = Interaction.GetText("Please enter InputFile");
inputFile = new FileInfo(inputFileName);
inputFile.Refresh();
}
var namePart = Path.Combine(Path.GetDirectoryName(inputFile.FullName), Path.GetFileNameWithoutExtension(inputFile.FullName));
var logfileName = namePart + ".log";
Interaction.Notice("LOG : " + logfileName);
var compositionCatalog = new DirectoryCatalog("./Plugins", "*.dll");
var compositionContainer = new CompositionContainer(compositionCatalog);
var dayFilters = compositionContainer.GetExports <ITrakkrDayFilter>();
var logFilters = compositionContainer.GetExports <ITrakkrLogFilter>();
bool failure;
do
{
var entries = ParseEvents(inputFile);
entries = entries
.GroupBy(e => e.Timestamp.Date)
.SelectMany(dateGroup =>
{
var result = dateGroup.AsEnumerable();
foreach (var dayFilter in dayFilters)
{
result = dayFilter.Value.Filter(result, dateGroup.Key);
}
return(result);
});
foreach (var logFilter in logFilters)
{
entries = logFilter.Value.Filter(entries);
}
var logger = new FileAppendLogger(logfileName, $"Updating Workitems : {DateTime.Now:O}");
failure = !UpdateWorkItems(connection, entries, logger);
}while (failure && Interaction.Confirm("Retry?"));
if (failure)
{
// do not show message when retry was declined
return;
}
Interaction.Acknowledge("Done (press any key).");
}
}
public object GetService(Type serviceType)
{
var export = container.GetExports(serviceType, null, null).SingleOrDefault();
return(null != export ? export.Value : null);
}
private IPythonInterpreterFactoryProvider[] LoadProviders(
SettingsStore store,
IServiceProvider serviceProvider
)
{
var seen = new HashSet <string>(StringComparer.OrdinalIgnoreCase);
var catalog = new List <ComposablePartCatalog>();
if (store.CollectionExists(SuppressFactoryProvidersCollection))
{
return(new IPythonInterpreterFactoryProvider[0]);
}
if (store.CollectionExists(FactoryProvidersCollection))
{
foreach (var idStr in store.GetSubCollectionNames(FactoryProvidersCollection))
{
var key = FactoryProvidersCollection + "\\" + idStr;
LoadOneProvider(
store.GetString(key, FactoryProviderCodeBaseSetting, ""),
seen,
catalog,
_activityLog
);
}
}
foreach (var baseKey in new[] { Registry.CurrentUser, Registry.LocalMachine })
{
using (var key = baseKey.OpenSubKey(FactoryProvidersRegKey)) {
if (key != null)
{
foreach (var idStr in key.GetSubKeyNames())
{
using (var subkey = key.OpenSubKey(idStr)) {
if (subkey != null)
{
LoadOneProvider(
subkey.GetValue(FactoryProviderCodeBaseSetting, "") as string,
seen,
catalog,
_activityLog
);
}
}
}
}
}
}
if (!catalog.Any())
{
LoadOneProvider(
typeof(CPythonInterpreterFactoryConstants).Assembly.Location,
seen,
catalog,
_activityLog
);
}
const string FailedToImportMessage = "Failed to import factory providers";
var providers = new List <IPythonInterpreterFactoryProvider>();
var serviceProviderProvider = new MockExportProvider();
if (serviceProvider != null)
{
serviceProviderProvider.SetExport(typeof(SVsServiceProvider), () => serviceProvider);
}
foreach (var part in catalog)
{
var container = new CompositionContainer(part, serviceProviderProvider);
try {
foreach (var provider in container.GetExports <IPythonInterpreterFactoryProvider>())
{
if (provider.Value != null)
{
providers.Add(provider.Value);
}
}
} catch (CompositionException ex) {
LogException(_activityLog, FailedToImportMessage, null, ex, ex.Errors);
} catch (ReflectionTypeLoadException ex) {
LogException(_activityLog, FailedToImportMessage, null, ex, ex.LoaderExceptions);
} catch (Exception ex) {
LogException(_activityLog, FailedToImportMessage, null, ex);
}
}
return(providers.ToArray());
}
protected static IEnumerable <ITechnologyPollingProvider> InitializeMEF(
ComposablePartCatalog catalog)
{
using (CompositionContainer compositionContainer = new CompositionContainer(catalog, Array.Empty <ExportProvider>()))
return((IEnumerable <ITechnologyPollingProvider>)compositionContainer.GetExports <ITechnologyPollingProvider>().Select <Lazy <ITechnologyPollingProvider>, ITechnologyPollingProvider>((Func <Lazy <ITechnologyPollingProvider>, ITechnologyPollingProvider>)(n => n.Value)).ToList <ITechnologyPollingProvider>());
}
private SourceRepository GetSourceRepository(string SourceUrl)
{
try
{
IEnumerable <Lazy <INuGetResourceProvider, INuGetResourceProviderMetadata> > providers = container.GetExports <INuGetResourceProvider, INuGetResourceProviderMetadata>();
StringBuilder sb = new StringBuilder();
foreach (var provider in providers)
{
sb.AppendLine(provider.Metadata.ResourceType.ToString());
}
Assert.True(providers.Count() > 0);
NuGet.Configuration.PackageSource source = new NuGet.Configuration.PackageSource(SourceUrl, "mysource", true);
SourceRepository repo = new SourceRepository(source, providers);
return(repo);
}
catch (Exception e)
{
Console.WriteLine(e.Message);
return(null);
}
}
protected void ImportThread()
{
_logger.Log(EErrorType.Info, "ImportThread started");
if (_compContainer != null)
{
// Clearing all errors
Errors.Clear();
// validating if there are anything need to be imported
CurrentState = EImportState.Init;
var sources = string.IsNullOrEmpty(_impParams.AgencyCode) ? _compContainer.GetExports <IQuotesSource>() : _compContainer.GetExports <IQuotesSource>(_impParams.AgencyCode);
IQuotesSourceCanImportParams canImportParams = null;
foreach (var s in sources)
{
// break if stopped
if (!_isRunning)
{
break;
}
var source = s;
if (source != null)
{
List <string> tickersToImport = new List <string>();
//if list of tickers is provided - checking which of them can be imported by the current source
if (_impParams.Tickers != null)
{
// checking which of the given tickers can be imported
canImportParams = source.Value.CreateCanImportParams();
_impParams.Tickers.ToList().ForEach(x => canImportParams.Tickers.Add(x));
IQuotesSourceCanImportResult canImportResult = source.Value.CanImport(canImportParams);
if (canImportResult.Success)
{
tickersToImport.AddRange(canImportResult.Tickers);
}
}
// starting import in two cases: 1) some tickers can be imported by this source OR 2) requested to import all possible tickers by given agency
if (tickersToImport.Count > 0 || (_impParams.Tickers == null && !string.IsNullOrEmpty(_impParams.AgencyCode)))
{
CurrentState = EImportState.ImportSources;
IQuotesSourceGetQuotesParams getQuotesParams = source.Value.CreateGetQuotesParams();
foreach (var t in tickersToImport)
{
getQuotesParams.Tickers.Add(t);
}
try
{
IQuotesDalSaveTimeseriesValuesParams saveParams = _dal.CreateSaveTimeseriesValuesParams();
getQuotesParams.Country = ConfigurationManager.AppSettings["DefaultCountry"];
getQuotesParams.PeriodStart = _impParams.DateStart;
getQuotesParams.PeriodEnd = _impParams.DateEnd;
getQuotesParams.TimeFrame = (ETimeFrame)_impParams.TimeFrame;
CurrentState = EImportState.ImportSources;
IQuotesSourceGetQuotesResult getQuotesResult = source.Value.GetQuotes(getQuotesParams);
saveParams.Quotes.AddRange(getQuotesResult.QuotesData);
CurrentState = EImportState.Saving;
IQuotesDalSaveTimeseriesValuesResult saveResult = _dal.SaveTimeseriesValues(saveParams);
if (saveResult.Success)
{
foreach (var t in tickersToImport)
{
_tickersProcessed.Add(t);
}
saveResult.TimeSeriesSaved.ToList().ForEach(x => { AddTickerForETL(x); });
}
_logger.Log(EErrorType.Info, string.Format("Import done"));
}
catch (Exception ex)
{
_logger.Log(ex);
Errors.Add(new Error()
{
Code = EErrorCodes.ImporterError, Type = EErrorType.Error, Message = string.Format("Import failed. Error: {0}", ex.Message)
});
}
}
}
} // foreach
}
else
{
Errors.Add(new Error()
{
Code = EErrorCodes.ImporterError, Type = EErrorType.Error, Message = "Import failed. Composition comtainer is NULL"
});
}
CurrentState = EImportState.Idle;
_isRunning = false;
_importEnd = DateTime.UtcNow;
_logger.Log(EErrorType.Info, string.Format("ImportThread finished. Total errors: {0}, Time: {1}", Errors.Count, _importEnd - _importStart));
}
private void HandleAddingPreCompiledPluginInDirectory(AggregateCatalog returnValue, string pluginDirectory)
{
List <Assembly> assemblies = new List <Assembly>();
var assembliesFiles = Directory.GetFiles(pluginDirectory, "*.dll");
foreach (string assemblyName in assembliesFiles)
{
try
{
if (IsAssemblyAlreadyReferenced(assemblyName))
{
string message = $"Warning: {pluginDirectory} - Skipping over assembly {assemblyName} because it is already loaded by a different plugin";
CompileOutput.Add(message);
}
else
{
var asm = Assembly.LoadFrom(assemblyName);
assemblies.Add(asm);
}
}
catch (Exception ex)
{
CompileErrors.Add(string.Format("Failed to load {0}: {1}", assemblyName, ex.Message));
}
}
AggregateCatalog catalogToMakeSureStuffIsLinked = new AggregateCatalog();
foreach (var assembly in assemblies)
{
var catalog = new AssemblyCatalog(assembly);
catalogToMakeSureStuffIsLinked.Catalogs.Add(catalog);
}
bool failed = false;
try
{
var container = new CompositionContainer(catalogToMakeSureStuffIsLinked);
container.GetExports <object>();
}
catch (Exception e)
{
string message = "";
message += "Error trying to load plugins from directory: " + pluginDirectory;
if (e is ReflectionTypeLoadException)
{
foreach (var innerException in (e as ReflectionTypeLoadException).LoaderExceptions)
{
message += "\r\n" + innerException.ToString();
}
}
else
{
message += "\r\n" + e.ToString();
}
CompileErrors.Add(message);
failed = true;
}
if (!failed)
{
foreach (var assemblyCatalog in catalogToMakeSureStuffIsLinked.Catalogs)
{
returnValue.Catalogs.Add(assemblyCatalog);
}
}
}
public IEnumerable <Lazy <T> > GetExports <T>()
{
return(_compositionContainer.GetExports <T>());
}
private void InitializeSecurityContext(StubNavigationService navigationService, out IMenuDefinition[] menus, out ISubMenuDefinition[] subMenus, out IServiceBus serviceBus)
{
// N'importer que les IMenuDefinition et ISubMenuDefinition
var menuDeftype = typeof(IMenuDefinition);
var subMenuDeftype = typeof(ISubMenuDefinition);
var assembly = typeof(KProcess.Ksmed.Presentation.Shell.Controller).Assembly;
// Rechercher les types qui les implémentent
var menuTypes = assembly.GetTypes().Where(t => t.GetInterface(menuDeftype.FullName) != null || t.GetInterface(subMenuDeftype.FullName) != null).ToArray();
// Composer MEF
var container = new CompositionContainer(
new AggregateCatalog(
new TypeCatalog(menuTypes),
new TypeCatalog(
typeof(IServiceBus), typeof(ServiceBus),
typeof(IEventBus), typeof(EventBus)
)));
CompositionBatch batch = new CompositionBatch();
batch.AddPart(this);
batch.AddExportedValue<CompositionContainer>(container);
//IoC.RegisterInstance<CompositionContainer>(_container);
container.Compose(batch);
menus = container.GetExports<IMenuDefinition>().Select(l => l.Value).ToArray();
subMenus = container.GetExports<ISubMenuDefinition>().Select(l => l.Value).ToArray();
foreach (var menu in menus)
{
menu.Initialize();
}
var rolesReadAuthorizations = new Dictionary<Type, string[]>();
var rolesWriteAuthorizations = new Dictionary<Type, string[]>();
var featuresReadAuthorizations = new Dictionary<Type, short[]>();
var featuresWriteAuthorizations = new Dictionary<Type, short[]>();
var customReadAuthorizations = new Dictionary<Type, Func<string, bool>>();
var customWriteAuthorizations = new Dictionary<Type, Func<string, bool>>();
var accessProjectContext = new Dictionary<Type, bool>();
foreach (var subMenu in subMenus)
{
subMenu.Initialize();
rolesReadAuthorizations[subMenu.ViewModelType] = subMenu.RolesCanRead;
rolesWriteAuthorizations[subMenu.ViewModelType] = subMenu.RolesCanWrite;
featuresReadAuthorizations[subMenu.ViewModelType] = subMenu.FeaturesCanRead;
featuresWriteAuthorizations[subMenu.ViewModelType] = subMenu.FeaturesCanWrite;
customReadAuthorizations[subMenu.ViewModelType] = subMenu.CustomCanRead;
customWriteAuthorizations[subMenu.ViewModelType] = subMenu.CustomCanWrite;
accessProjectContext[subMenu.ViewModelType] = subMenu.IsSecurityProjectContext;
}
Security.SecurityContext.RegisterAuthorizations(
rolesReadAuthorizations,
rolesWriteAuthorizations,
featuresReadAuthorizations,
featuresWriteAuthorizations,
customReadAuthorizations,
customWriteAuthorizations);
serviceBus = container.GetExport<IServiceBus>().Value;
serviceBus.Register<INavigationService>(navigationService);
serviceBus.Register<IProjectManagerService>(new StubProjectManagerService());
}
public void Initialise(Scene scene, IConfigSource config)
{
string desiredWindPlugin = DEFAULT_WIND_PLUGIN;
IConfig windConfig = config.Configs["Wind"];
if (windConfig != null)
{
m_enabled = windConfig.GetBoolean("enabled", true);
m_frameUpdateRate = windConfig.GetInt("wind_update_rate", 150);
// Determine which wind model plugin is desired
if (windConfig.Contains("wind_plugin"))
{
desiredWindPlugin = windConfig.GetString("wind_plugin");
}
}
if (m_enabled)
{
m_log.InfoFormat("[WIND] Enabled with an update rate of {0} frames.", m_frameUpdateRate);
m_scene = scene;
m_frame = 0;
if (windConfig != null)
{
CompositionContainer moduleContainer = scene.ModuleContainer;
IEnumerable <Lazy <object, object> > exportEnumerable = moduleContainer.GetExports(typeof(IPlugin), null, null);
foreach (Lazy <object, object> lazyExport in exportEnumerable)
{
IDictionary <string, object> metadata = (IDictionary <string, object>)lazyExport.Metadata;
object nameObj;
if (metadata.TryGetValue("Name", out nameObj))
{
string name = (string)nameObj;
if (name.Equals(desiredWindPlugin, StringComparison.InvariantCultureIgnoreCase) && lazyExport.Value is IWindModelPlugin)
{
m_log.InfoFormat("[WIND] {0} plugin found, initializing.", desiredWindPlugin);
m_activeWindPlugin = (IWindModelPlugin)lazyExport.Value;
m_activeWindPlugin.Initialise();
m_activeWindPlugin.WindConfig(m_scene, windConfig);
break;
}
}
}
}
// if the plug-in wasn't found, default to no wind.
if (m_activeWindPlugin == null)
{
m_log.ErrorFormat("[WIND] Could not find specified wind plug-in: {0}", desiredWindPlugin);
m_log.ErrorFormat("[WIND] Defaulting to no wind.");
}
// This one puts an entry in the main help screen
m_scene.AddCommand(this, String.Empty, "wind", "Usage: wind <param> [value] - Get or Update Wind paramaters", null);
// This one enables the ability to type just the base command without any parameters
m_scene.AddCommand(this, "wind", "", "", HandleConsoleCommand);
// Get a list of the parameters for the plugin
if (m_activeWindPlugin != null)
{
m_scene.AddCommand(this, String.Format("wind wind_update_rate"), "Change the wind update rate.", "", HandleConsoleBaseCommand);
foreach (KeyValuePair <string, string> kvp in m_activeWindPlugin.WindParams())
{
m_scene.AddCommand(this, String.Format("wind {0} {1}", m_activeWindPlugin.Name, kvp.Key),
String.Format("{0} : {1} - {2}", m_activeWindPlugin.Name, kvp.Key, kvp.Value), "", HandleConsoleParamCommand);
}
}
// Register event handlers for when Avatars enter the region, and frame ticks
m_scene.EventManager.OnFrame += WindUpdate;
m_scene.EventManager.OnMakeRootAgent += OnAgentEnteredRegion;
// Register the wind module
m_scene.RegisterModuleInterface <IWindModule>(this);
// Generate initial wind values
GenWindPos();
// Mark Module Ready for duty
m_ready = true;
}
}
public bool LoadModules()
{
#region Application Module Whitelist Loading
// Load the application module whitelist
List <KeyValuePair <int, string> > whitelist = new List <KeyValuePair <int, string> >();
IConfig config = Config.Configs["ApplicationModules"];
if (config != null)
{
foreach (string key in config.GetKeys())
{
int runLevel = config.GetInt(key, -1);
if (runLevel >= 0)
{
whitelist.Add(new KeyValuePair <int, string>(runLevel, key));
}
}
}
// Sort the list based on runlevel
whitelist.Sort(delegate(KeyValuePair <int, string> lhs, KeyValuePair <int, string> rhs) { return(lhs.Key.CompareTo(rhs.Key)); });
#endregion Application Module Whitelist Loading
#region Module Container Loading
AggregateCatalog catalog = new AggregateCatalog();
AssemblyCatalog assemblyCatalog = new AssemblyCatalog(System.Reflection.Assembly.GetExecutingAssembly());
DirectoryCatalog directoryCatalog = new DirectoryCatalog(".", "Simian.*.dll");
catalog.Catalogs.Add(assemblyCatalog);
catalog.Catalogs.Add(directoryCatalog);
m_moduleContainer = new CompositionContainer(catalog, true);
try
{
m_log.InfoFormat("Found {0} modules in the current assembly and {1} modules in external assemblies",
assemblyCatalog.Parts.Count(), directoryCatalog.Parts.Count());
}
catch (System.Reflection.ReflectionTypeLoadException ex)
{
StringBuilder error = new StringBuilder("Error(s) encountered loading extension modules. You may have an incompatible or out of date extension .dll in the current folder.");
foreach (Exception loaderEx in ex.LoaderExceptions)
{
error.Append("\n " + loaderEx.Message);
}
m_log.Error(error.ToString());
return(false);
}
#endregion Module Container Loading
#region Module Loading
IEnumerable <Lazy <object, object> > exportEnumerable = m_moduleContainer.GetExports(typeof(IApplicationModule), null, null);
Dictionary <string, Lazy <object, object> > exports = new Dictionary <string, Lazy <object, object> >();
List <IApplicationModule> imports = new List <IApplicationModule>();
List <string> notLoaded = new List <string>();
// Reshuffle exportEnumerable into a dictionary mapping module names to their lazy instantiations
foreach (Lazy <object, object> lazyExport in exportEnumerable)
{
IDictionary <string, object> metadata = (IDictionary <string, object>)lazyExport.Metadata;
object nameObj;
if (metadata.TryGetValue("Name", out nameObj))
{
string name = (string)nameObj;
if (!exports.ContainsKey(name))
{
exports.Add(name, lazyExport);
}
else
{
m_log.Warn("Found an IApplicationModule with a duplicate name: " + name);
}
}
}
// Load modules in the order they appear in the whitelist
foreach (KeyValuePair <int, string> kvp in whitelist)
{
string whitelisted = kvp.Value;
Lazy <object, object> lazyExport;
if (exports.TryGetValue(whitelisted, out lazyExport))
{
imports.Add((IApplicationModule)lazyExport.Value);
exports.Remove(whitelisted);
}
else
{
notLoaded.Add(whitelisted);
}
}
// Populate m_applicationModules
m_applicationModules = imports.ToArray();
// Start the application modules
for (int i = 0; i < m_applicationModules.Length; i++)
{
IApplicationModule module = m_applicationModules[i];
if (!(module is ISceneFactory))
{
module.Start(this);
}
}
// ISceneFactory modules are always started last
for (int i = 0; i < m_applicationModules.Length; i++)
{
IApplicationModule module = m_applicationModules[i];
if (module is ISceneFactory)
{
module.Start(this);
}
}
#endregion Module Loading
#region Logging
m_log.InfoFormat("Loaded {0} application modules", m_applicationModules.Length);
if (exports.Count > 0)
{
StringBuilder skippedStr = new StringBuilder("Skipped application modules: ");
foreach (string exportName in exports.Keys)
{
skippedStr.Append(exportName + " ");
}
m_log.Info(skippedStr.ToString());
}
if (notLoaded.Count > 0)
{
StringBuilder notLoadedStr = new StringBuilder("Did not load whitelisted application modules: ");
foreach (string entry in notLoaded)
{
notLoadedStr.Append(entry + " ");
}
m_log.Warn(notLoadedStr.ToString());
}
#endregion Logging
// Get a reference to the HTTP server if we have one
m_httpServer = GetAppModule <IHttpServer>();
if (m_httpServer != null)
{
m_capabilityRouter = new CapabilityRouter(m_httpServer.HttpAddress.Combine(CAPABILITY_PATH));
m_httpServer.AddHandler(null, null, CAPABILITY_PATH, false, false, m_capabilityRouter.RouteCapability);
}
// Get a reference to the ISceneFactory if we have one
m_sceneFactory = GetAppModule <ISceneFactory>();
if (m_sceneFactory != null)
{
AddCommandHandler("scene", SceneHandler);
}
return(true);
}
public static Dictionary <ClientSample, IEnumerable <RunnableClientSampleMethod> > GetRunnableClientSampleMethods(string area = null, string resource = null)
{
Dictionary <ClientSample, IEnumerable <RunnableClientSampleMethod> > results = new Dictionary <ClientSample, IEnumerable <RunnableClientSampleMethod> >();
CompositionContainer container = new CompositionContainer(new AssemblyCatalog(Assembly.GetExecutingAssembly()));
IEnumerable <Lazy <ClientSample> > samples = container.GetExports <ClientSample>();
foreach (Lazy <ClientSample> cs in samples)
{
try
{
Type csType = cs.Value.GetType();
ClientSampleAttribute csAttr = csType.GetCustomAttribute <ClientSampleAttribute>();
List <RunnableClientSampleMethod> runnableMethods = new List <RunnableClientSampleMethod>();
foreach (MethodInfo m in csType.GetMethods())
{
ClientSampleMethodAttribute[] attrs = (ClientSampleMethodAttribute[])m.GetCustomAttributes(typeof(ClientSampleMethodAttribute), false);
foreach (var ma in attrs)
{
RunnableClientSampleMethod runnableMethod = new RunnableClientSampleMethod();
if (string.IsNullOrEmpty(ma.Area))
{
runnableMethod.Area = csAttr.Area;
}
else
{
runnableMethod.Area = ma.Area;
}
if (string.IsNullOrEmpty(ma.Resource))
{
runnableMethod.Resource = csAttr.Resource;
}
else
{
runnableMethod.Resource = ma.Resource;
}
if (!string.IsNullOrEmpty(runnableMethod.Area) && !string.IsNullOrEmpty(runnableMethod.Resource))
{
runnableMethod.MethodBase = m;
runnableMethods.Add(runnableMethod);
}
}
}
if (runnableMethods.Any())
{
if (!String.IsNullOrEmpty(area))
{
runnableMethods = runnableMethods.FindAll(
rcsm =>
{
return(string.Equals(area, rcsm.Area, StringComparison.InvariantCultureIgnoreCase) &&
(resource == null || string.Equals(resource, rcsm.Resource, StringComparison.InvariantCultureIgnoreCase)));
}
);
}
results.Add(cs.Value, runnableMethods);
}
}
catch (Exception ex)
{
System.Diagnostics.Debug.WriteLine(ex.Message);
}
}
return(results);
}
public SourceRepository GetSourceRepository(NuGet.IPackageRepository legacyRepo)
{
V2PackageSource source = new V2PackageSource(@"passed in", () => legacyRepo);
IEnumerable <Lazy <INuGetResourceProvider, INuGetResourceProviderMetadata> > providers = Container.GetExports <INuGetResourceProvider, INuGetResourceProviderMetadata>();
Assert.True(providers.Count() > 0);
SourceRepository repo = new SourceRepository(source, providers);
return(repo);
}
public void ImportAll(out IReadOnlyCollection <ImportedMigration> migrations, out IReadOnlyCollection <ImportedAggregateMigration> aggregateMigrations)
{
Log.Info("Importing migrations...");
DateTime start = DateTime.Now;
var container = new CompositionContainer(_catalog);
IEnumerable <Lazy <IMigration, IMigrationExportMetadata> > migrationExports = container.GetExports <IMigration, IMigrationExportMetadata>();
IEnumerable <Lazy <IMigration, IAggregateMigrationExportMetadata> > aggregateMigrationExports = container.GetExports <IMigration, IAggregateMigrationExportMetadata>(AggregateMigrationExportAttribute.ContractName);
migrations = migrationExports
.Select(l =>
{
var timestamp = ExtractTimestamp(l.Metadata.ModuleName, l.Value);
var migrationMetadata = new MigrationMetadata(timestamp, l.Metadata.ModuleName, l.Metadata.Tag);
return(new ImportedMigration(l.Value, migrationMetadata, l.Metadata.UseModuleNameAsDefaultSchema));
}).ToList();
aggregateMigrations = aggregateMigrationExports
.Select(l =>
{
var timestamp = ExtractTimestamp(l.Metadata.ModuleName, l.Value);
var aggregateMigrationMetadata = new AggregateMigrationMetadata(timestamp, l.Metadata.ModuleName);
return(new ImportedAggregateMigration(l.Value, aggregateMigrationMetadata));
}).ToList();
Log.Verbose(LogCategory.Performance, "Importing migrations took {0}s", (DateTime.Now - start).TotalSeconds);
Log.Info("Found {0} migration(s) and {1} aggregate migration(s)", migrations.Count, aggregateMigrations.Count);
}
void ImportPlugins()
{
myPlugins = _container.GetExports <T, TMetadata>();
}
public static object[] GetExportedValues(this CompositionContainer container, Type type, string contractName = null)
{
var exports = container.GetExports(type, null, contractName);
return(exports.Select(it => it.Value).ToArray());
}
static IEnumerable <T> GetAllExports <T>(this CompositionContainer container)
{
return(container.GetExports <T>().Select(x => x.Value));
}
//=====================================================================
/// <summary>
/// Constructor
/// </summary>
/// <param name="configuration">The current configuration in an XML fragment</param>
/// <param name="container">The composition container user to locate the syntax generators</param>
public SyntaxComponentConfigDlg(string configuration, CompositionContainer container)
{
HashSet <string> generatorIds = new HashSet <string>();
XElement node;
XAttribute attr;
bool value;
InitializeComponent();
syntaxGenerators = new List <SyntaxGeneratorSettings>();
// Get a list of all configurable syntax generators
try
{
var generators = container.GetExports <ISyntaxGeneratorFactory, ISyntaxGeneratorMetadata>().Select(
g => g.Metadata).ToList();
// There may be duplicate generator IDs across the assemblies found. See
// BuildComponentManger.GetComponentContainer() for the folder search precedence. Only the
// first component for a unique ID will be used.
foreach (var generator in generators)
{
if (!generatorIds.Contains(generator.Id))
{
syntaxGenerators.Add(new SyntaxGeneratorSettings
{
Id = generator.Id,
SortOrder = generator.SortOrder,
IsConfigurable = generator.IsConfigurable,
DefaultConfiguration = generator.DefaultConfiguration,
CurrentConfiguration = generator.DefaultConfiguration
});
generatorIds.Add(generator.Id);
}
}
}
catch (Exception ex)
{
syntaxGenerators = new List <SyntaxGeneratorSettings>();
btnOK.Enabled = false;
MessageBox.Show("Unable to obtain a list of syntax generators: " + ex.Message, "Syntax Component",
MessageBoxButtons.OK, MessageBoxIcon.Exclamation);
}
// Load the current settings
config = XElement.Parse(configuration);
node = config.Element("syntax");
if (node != null)
{
attr = node.Attribute("renderReferenceLinks");
if (!Boolean.TryParse(attr.Value, out value))
{
value = false;
}
chkRenderReferenceLinks.Checked = value;
}
node = config.Element("containerElement");
if (node != null)
{
attr = node.Attribute("addNoExampleTabs");
if (!Boolean.TryParse(attr.Value, out value))
{
value = false;
}
chkAddNoExampleTabs.Checked = value;
if (value)
{
attr = node.Attribute("includeOnSingleSnippets");
if (!Boolean.TryParse(attr.Value, out value))
{
value = false;
}
chkIncludeOnSingleSnippets.Checked = value;
}
}
// Configurations are stored separately since the actual syntax filters are added at build time
node = config.Element("configurations");
if (node != null)
{
int idx = 0;
foreach (var generator in node.Descendants("generator"))
{
var sg = syntaxGenerators.FirstOrDefault(g => g.Id == generator.Attribute("id").Value);
if (sg != null)
{
var reader = generator.CreateReader();
reader.MoveToContent();
sg.SortOrder = idx;
if (sg.IsConfigurable)
{
sg.CurrentConfiguration = reader.ReadInnerXml();
}
}
idx++;
}
}
foreach (var generator in syntaxGenerators.OrderBy(g => g.SortOrder))
{
tvGenerators.Nodes.Add(generator.Id);
}
if (tvGenerators.Nodes.Count != 0)
{
tvGenerators.SelectedNode = tvGenerators.Nodes[0];
}
else
{
btnReset.Enabled = txtConfiguration.Enabled = btnMoveUp.Enabled = btnMoveDown.Enabled = false;
}
}
protected void Application_Start()
{
// TODO maybe put this somewhere else (not in global.asax)
// TODO maybe move all of this into the App class with "IAppConfig"
// initialize logger
TraceListener traceListener =
new TextWriterTraceListener(Path.Combine(AppConfig.LogPath,
string.Format("repository_{0:yyyy'-'MM'-'dd__HHmmss}.log",
DateTime.Now)));
// TODO introduce flags/settings for controlling logging levels, but for now include everything
traceListener.Filter = new EventTypeFilter(SourceLevels.All);
traceListener.TraceOutputOptions = TraceOptions.ThreadId | TraceOptions.DateTime;
Web.TraceSources.Content.Listeners.Add(traceListener);
Web.TraceSources.AddInManager.Listeners.Add(traceListener);
Repository.TraceSources.ContentManagerSource.Listeners.Add(traceListener);
Repository.TraceSources.ContentSearcherSource.Listeners.Add(traceListener);
// this might be stupid, but it fixes things for iisexpress
Directory.SetCurrentDirectory(HostingEnvironment.ApplicationPhysicalPath);
// set up add-in system
AddInSource officalSource = new AddInSource("Official LostDoc repository add-in feed",
AppConfig.AddInRepository,
isOfficial: true);
// intialize MEF
// core 'add-ins'
var currentAssembly = Assembly.GetExecutingAssembly();
var assemblyName = currentAssembly.GetName();
string corePackageId = assemblyName.Name;
string corePackageVersion = assemblyName.Version.ToString();
AggregateCatalog catalog = new AggregateCatalog();
// load other sources from site-settings (not config)
AddInRepository repository = new AddInRepository(officalSource);
AddInManager addInManager = new AddInManager(repository,
AppConfig.AddInInstallPath,
AppConfig.AddInPackagePath);
// when the catalog changes, discover and route all ApiControllers
catalog.Changed += (sender, args) => this.UpdateWebApiRegistry(args);
//// TODO for debugging only
//Debugger.Break();
//Debugger.Launch();
// now register core libs
catalog.Catalogs.Add(new AddInCatalog(new ApplicationCatalog(), corePackageId, corePackageVersion));
// hook event so that installed add-ins get registered in the catalog, if composition occurs after this fires
// or if recomposition is enabled, no restart should be requried
addInManager.Installed +=
(sender, args) => catalog.Catalogs.Add(new AddInCatalog(new DirectoryCatalog(args.InstallationPath),
args.Package.Id,
args.Package.Version));
// delete and redeploy all installed packages, this will trigger the Installed event ^
// this acts as a crude "remove/overwrite plugins that were in use when un/installed" hack
addInManager.Restore();
// create container
CompositionContainer container = new CompositionContainer(catalog);
// set up template resolver
var lazyProviders = container.GetExports <IFileProvider>(ContractNames.TemplateProvider);
var realProviders = lazyProviders.Select(lazy => lazy.Value);
TemplateResolver templateResolver = new TemplateResolver(realProviders.ToArray());
// load template
Template template = new Template(container);
template.Load(templateResolver, AppConfig.Template);
// set up content manager
ContentManager contentManager = new ContentManager(new ContentSettings
{
ContentPath = AppConfig.ContentPath,
// TODO make this configurable
IgnoreVersionComponent = VersionComponent.Patch,
RepositoryPath = AppConfig.RepositoryPath,
Template = template
});
// set up notifaction system
NotificationManager notifications = new NotificationManager();
// initialize app-singleton
App.Initialize(container, contentManager, addInManager, notifications, traceListener);
// MVC init
AreaRegistration.RegisterAllAreas();
RegisterGlobalFilters(GlobalFilters.Filters);
RegisterRoutes(RouteTable.Routes);
// inject our custom IControllerFactory for the Admin interface
IControllerFactory oldControllerFactory = ControllerBuilder.Current.GetControllerFactory();
IControllerFactory newControllerFactory = new AddInControllerFactory(AdministrationAreaRegistration.Name,
container,
oldControllerFactory);
ControllerBuilder.Current.SetControllerFactory(newControllerFactory);
// TODO figure out if we actually need this
// hook in our MEF based IHttpController instead of the default one
//GlobalConfiguration.Configuration.Services.Replace(typeof(IHttpControllerTypeResolver), new AddInHttpControllerTypeResolver(App.Instance.Container));
}
//=====================================================================
/// <summary>
/// Try to load information about all available presentation styles so that their arguments can be loaded
/// for use in the project.
/// </summary>
/// <returns>True on success, false on failure or if no project is loaded</returns>
private void LoadAvailablePresentationStyles()
{
SandcastleProject currentProject = null;
HashSet <string> presentationStyleIds = new HashSet <string>();
string[] searchFolders;
try
{
Cursor.Current = Cursors.WaitCursor;
if (componentContainer != null)
{
componentContainer.Dispose();
componentContainer = null;
}
presentationStyles = new List <Lazy <PresentationStyleSettings, IPresentationStyleMetadata> >();
#if !STANDALONEGUI
if (base.ProjectMgr != null)
{
currentProject = ((SandcastleBuilderProjectNode)base.ProjectMgr).SandcastleProject;
}
#else
currentProject = base.CurrentProject;
#endif
lastProjectName = currentProject == null ? null : currentProject.Filename;
if (currentProject != null)
{
searchFolders = new[] { currentProject.ComponentPath, Path.GetDirectoryName(currentProject.Filename) }
}
;
else
{
searchFolders = new string[] { }
};
componentContainer = ComponentUtilities.CreateComponentContainer(searchFolders);
// There may be duplicate presentation style IDs across the assemblies found. See
// BuildComponentManger.GetComponentContainer() for the folder search precedence. Only the
// first component for a unique ID will be used.
foreach (var style in componentContainer.GetExports <PresentationStyleSettings,
IPresentationStyleMetadata>())
{
if (!presentationStyleIds.Contains(style.Metadata.Id))
{
presentationStyles.Add(style);
presentationStyleIds.Add(style.Metadata.Id);
}
}
}
catch (Exception ex)
{
System.Diagnostics.Debug.WriteLine(ex.ToString());
MessageBox.Show("Unexpected error loading presentation styles: " + ex.Message, messageBoxTitle,
MessageBoxButtons.OK, MessageBoxIcon.Error);
}
finally
{
Cursor.Current = Cursors.Default;
}
}
public TDSListener(TDSProxyService service, ListenerElement configuration)
{
var insideAddresses = Dns.GetHostAddresses(configuration.ForwardToHost);
if (0 == insideAddresses.Length)
{
log.ErrorFormat("Unable to resolve forwardToHost=\"{0}\" for listener {1}", configuration.ForwardToHost, configuration.Name);
_stopped = true;
return;
}
ForwardTo = new IPEndPoint(insideAddresses.First(), configuration.ForwardToPort);
_service = service;
var bindToEP = new IPEndPoint(configuration.BindToAddress ?? IPAddress.Any, configuration.ListenOnPort);
try
{
var catalog = new AggregateCatalog(from AuthenticatorElement a in configuration.Authenticators
select new AssemblyCatalog(a.Dll));
_mefContainer = new CompositionContainer(catalog);
var allExports = _mefContainer.GetExports <IAuthenticator>().ToDictionary(a => a.GetType().GetGenericArguments()[0].FullName);
var authenticators = new Lazy <IAuthenticator> [configuration.Authenticators.Count];
bool die = false;
var used = new List <Lazy <IAuthenticator> >();
for (int i = 0; i < configuration.Authenticators.Count; i++)
{
var a = configuration.Authenticators[i];
if (!allExports.TryGetValue(a.Class, out var export))
{
log.ErrorFormat(
"For authenticator {0} found dll {1} but not class {2} (exports in catalog: {3})",
a.Name,
a.Dll,
a.Class,
string.Join("; ", allExports.Keys));
die = true;
}
used.Add(export);
authenticators[i] = export;
}
if (die)
{
Dispose();
return;
}
_authenticators = authenticators;
_mefContainer.ReleaseExports(allExports.Values.Except(used));
}
catch (CompositionException ce)
{
log.Error(
"Failed to find an authenticator. Composition errors:\r\n\t" +
string.Join("\r\n\t", ce.Errors.Select(err => "Element: " + err.Element.DisplayName + ", Error: " + err.Description)),
ce);
Dispose();
return;
}
catch (Exception e)
{
log.Error("Failed to find an authenticator", e);
Dispose();
return;
}
try
{
log.DebugFormat("Opening SSL certificate store {0}.{1}", configuration.SslCertStoreLocation, configuration.SslCertStoreName);
var store = new X509Store(configuration.SslCertStoreName, configuration.SslCertStoreLocation);
store.Open(OpenFlags.ReadOnly | OpenFlags.OpenExistingOnly);
var matching = store.Certificates.Find(X509FindType.FindByThumbprint, configuration.SslCertSubjectThumbprint, false);
if (0 == matching.Count)
{
log.ErrorFormat(
"Failed to find SSL certification with thumbprint '{0}' in location {1}, store {2}.",
configuration.SslCertSubjectThumbprint,
configuration.SslCertStoreLocation,
configuration.SslCertStoreName);
Dispose();
return;
}
Certificate = matching[0];
}
catch (Exception e)
{
log.Error("Failed to load SSL certificate", e);
Dispose();
return;
}
_tcpListener = new TcpListener(bindToEP);
_tcpListener.Start();
_tcpListener.BeginAcceptTcpClient(AcceptConnection, _tcpListener);
_service.AddListener(this);
log.InfoFormat(
"Listening on {0} and forwarding to {1} (SSL cert DN {2}; expires {5} serial {3}; authenticators {4})",
bindToEP,
ForwardTo,
Certificate.Subject,
Certificate.GetSerialNumberString(),
string.Join(", ", from a in Authenticators select a.GetType().FullName),
Certificate.GetExpirationDateString());
}
public void SelectiveImportBySTMThroughCatalog1(CompositionContainer container)
{
Assert.NotNull(container.GetExport <IMyExporter, IMetadataView>());
var result2 = container.GetExports <IMyExporter, IMetadataView>();
}
//=====================================================================
/// <summary>
/// Try to load information about all available plug-ins so that they can be added to the project
/// </summary>
/// <returns>True on success, false on failure or if no project is loaded</returns>
private void LoadAvailablePlugInMetadata()
{
SandcastleProject currentProject = null;
HashSet <string> plugInIds = new HashSet <string>();
try
{
Cursor.Current = Cursors.WaitCursor;
if (componentContainer != null)
{
componentContainer.Dispose();
componentContainer = null;
availablePlugIns = null;
}
#if !STANDALONEGUI
if (base.ProjectMgr != null)
{
currentProject = ((SandcastleBuilderProjectNode)base.ProjectMgr).SandcastleProject;
}
#else
currentProject = base.CurrentProject;
#endif
lastProjectName = currentProject == null ? null : currentProject.Filename;
if (currentProject != null)
{
componentContainer = ComponentUtilities.CreateComponentContainer(new[] {
currentProject.ComponentPath, Path.GetDirectoryName(currentProject.Filename)
});
}
else
{
componentContainer = ComponentUtilities.CreateComponentContainer(new string[] { });
}
lbProjectPlugIns.Items.Clear();
availablePlugIns = componentContainer.GetExports <IPlugIn, IPlugInMetadata>().ToList();
// There may be duplicate component IDs across the assemblies found. See
// BuildComponentManger.GetComponentContainer() for the folder search precedence. Only the first
// component for a unique ID will be used. We also ignore hidden plug-ins.
foreach (var plugIn in availablePlugIns)
{
if (!plugIn.Metadata.IsHidden && !plugInIds.Contains(plugIn.Metadata.Id))
{
lbAvailablePlugIns.Items.Add(plugIn.Metadata.Id);
plugInIds.Add(plugIn.Metadata.Id);
}
}
}
catch (Exception ex)
{
System.Diagnostics.Debug.WriteLine(ex.ToString());
MessageBox.Show("Unexpected error loading plug-ins: " + ex.Message, messageBoxTitle,
MessageBoxButtons.OK, MessageBoxIcon.Error);
}
finally
{
Cursor.Current = Cursors.Default;
}
if (lbAvailablePlugIns.Items.Count != 0)
{
lbAvailablePlugIns.SelectedIndex = 0;
gbAvailablePlugIns.Enabled = gbProjectAddIns.Enabled = true;
}
else
{
MessageBox.Show("No valid plug-ins found", messageBoxTitle, MessageBoxButtons.OK,
MessageBoxIcon.Information);
gbAvailablePlugIns.Enabled = gbProjectAddIns.Enabled = false;
}
}