/// <summary>
/// Hydrates the properties from the registry asyncronously.
/// </summary>
public virtual async Task LoadAsync()
{
ShellSettingsManager manager = await _settingsManager.GetValueAsync();
SettingsStore settingsStore = manager.GetReadOnlySettingsStore(SettingsScope.UserSettings);
if (!settingsStore.CollectionExists(CollectionName))
{
return;
}
foreach (PropertyInfo property in GetOptionProperties())
{
try
{
string serializedProp = settingsStore.GetString(CollectionName, property.Name);
object value = DeserializeValue(serializedProp, property.PropertyType);
property.SetValue(this, value);
}
catch (Exception ex)
{
System.Diagnostics.Debug.Write(ex);
}
}
}
private static bool?GetOutOfProcessSettingFromSessionStore(AcuminatorVSPackage package)
{
const bool defaultOutOfProcessValue = true;
const string settingsStoreOutOfProcessValuePath = @"Roslyn\Internal\OnOff\Features";
const string OutOfProcessPropertyName = "OOP64Bit";
var shellSettingsManager = new ShellSettingsManager(package);
SettingsStore settingsStore = shellSettingsManager.GetReadOnlySettingsStore(SettingsScope.UserSettings);
if (settingsStore == null)
{
return(null);
}
else if (!settingsStore.CollectionExists(settingsStoreOutOfProcessValuePath))
{
return(defaultOutOfProcessValue);
}
var propertyNames = settingsStore.GetPropertyNames(settingsStoreOutOfProcessValuePath);
if (!propertyNames.Contains(OutOfProcessPropertyName))
{
return(defaultOutOfProcessValue);
}
int?outOfProcessValue = settingsStore.GetInt32(settingsStoreOutOfProcessValuePath, OutOfProcessPropertyName) as int?;
return(outOfProcessValue.HasValue
? outOfProcessValue == 1
: defaultOutOfProcessValue);
}
/// <summary>
/// Initialization of the package; this method is called right after the package is sited, so this is the place
/// where you can put all the initialization code that rely on services provided by VisualStudio.
/// </summary>
protected override void Initialize()
{
CompareDirectoriesCommand.Initialize(this);
base.Initialize();
using (ServiceProvider serviceProvider = new ServiceProvider((IServiceProvider)(Package.GetGlobalService(typeof(IServiceProvider)))))
{
SettingsManager settingsManager = new ShellSettingsManager(serviceProvider);
SettingsStore settingsStore = settingsManager.GetReadOnlySettingsStore(SettingsScope.UserSettings);
if (settingsStore.CollectionExists(FilterSettings))
{
IEnumerable <string> propertyNames = settingsStore.GetPropertyNames(FilterSettings);
foreach (string propertyName in propertyNames)
{
var filter = settingsStore.GetString(FilterSettings, propertyName, null);
if (filter != null)
{
CommonFilters.Add(filter);
}
}
}
}
if (CommonFilters.Count == 0)
{
CommonFilters.Add("-*.dll;-*.pdb;-*.obj;-*.exe;-*.vsix;-.vs\\*;-*obj\\*;-*bin\\*;-.git\\*;-packages\\*");
CommonFilters.Add("*.cs;*.vb;*.c;*.cpp;*.h");
CommonFilters.Add(string.Empty);
}
}
private void GeneralOptionLoad(SettingsStore settingsStore)
{
if (!settingsStore.CollectionExists(CollectionName))
{
return;
}
_generalOptionProvider.SortOptions = ReadSetting <GeneralOptionPage.SortState>(settingsStore, nameof(_generalOptionProvider.SortOptions));
_generalOptionProvider.AutoScroll = ReadSetting <bool>(settingsStore, nameof(_generalOptionProvider.AutoScroll));
_generalOptionProvider.IsEnabledIndentGuides = ReadSetting <bool>(settingsStore, nameof(_generalOptionProvider.IsEnabledIndentGuides));
_generalOptionProvider.IndentGuideThickness = ReadSetting <double>(settingsStore, nameof(_generalOptionProvider.IndentGuideThickness));
_generalOptionProvider.IndentGuideDashSize = ReadSetting <double>(settingsStore, nameof(_generalOptionProvider.IndentGuideDashSize));
_generalOptionProvider.IndentGuideSpaceSize = ReadSetting <double>(settingsStore, nameof(_generalOptionProvider.IndentGuideSpaceSize));
_generalOptionProvider.IndentGuideOffsetY = ReadSetting <double>(settingsStore, nameof(_generalOptionProvider.IndentGuideOffsetY));
_generalOptionProvider.IndentGuideOffsetX = ReadSetting <double>(settingsStore, nameof(_generalOptionProvider.IndentGuideOffsetX));
_generalOptionProvider.Asm1FileExtensions = ReadSetting <IReadOnlyList <string> >(settingsStore, nameof(_generalOptionProvider.Asm1FileExtensions));
_generalOptionProvider.Asm2FileExtensions = ReadSetting <IReadOnlyList <string> >(settingsStore, nameof(_generalOptionProvider.Asm2FileExtensions));
_generalOptionProvider.Asm1SelectedSet = ReadSetting <string>(settingsStore, nameof(_generalOptionProvider.Asm1SelectedSet));
_generalOptionProvider.Asm2SelectedSet = ReadSetting <string>(settingsStore, nameof(_generalOptionProvider.Asm2SelectedSet));
_generalOptionProvider.AutocompleteInstructions = ReadSetting <bool>(settingsStore, nameof(_generalOptionProvider.AutocompleteInstructions));
_generalOptionProvider.AutocompleteFunctions = ReadSetting <bool>(settingsStore, nameof(_generalOptionProvider.AutocompleteFunctions));
_generalOptionProvider.AutocompleteLabels = ReadSetting <bool>(settingsStore, nameof(_generalOptionProvider.AutocompleteLabels));
_generalOptionProvider.AutocompleteVariables = ReadSetting <bool>(settingsStore, nameof(_generalOptionProvider.AutocompleteVariables));
_generalOptionProvider.SignatureHelp = ReadSetting <bool>(settingsStore, nameof(_generalOptionProvider.SignatureHelp));
}
public string ReadStringData(string key)
{
try
{
if (!_readOnlySettingsStore.CollectionExists(tasCollectionPath))
{
_logger.Error($"Attempted to read user settings store value under \"{tasCollectionPath}\" but no such collection path exists");
return(null);
}
if (_readOnlySettingsStore.PropertyExists(tasCollectionPath, key))
{
return(_readOnlySettingsStore.GetString(tasCollectionPath, key));
}
else
{
_logger.Error($"Attempted to read user settings store value for \"{key}\" but no such property exists");
return(null);
}
}
catch (Exception ex)
{
_logger.Error(ex.Message);
return(null);
}
}
/// <summary>
/// Hydrates the properties from the registry asyncronously.
/// </summary>
public virtual async Task LoadAsync()
{
ShellSettingsManager manager = await _settingsManager.GetValueAsync();
SettingsStore settingsStore = manager.GetReadOnlySettingsStore(SettingsScope.UserSettings);
if (!settingsStore.CollectionExists(CollectionName))
{
return;
}
foreach (PropertyInfo property in GetOptionProperties())
{
try
{
var serializedProp = settingsStore.GetString(CollectionName, property.Name, default);
var value = DeserializeValue(serializedProp, property.PropertyType);
property.SetValue(this, value);
}
catch
{
// Do nothing here
}
}
}
/// <summary>
/// Hydrates the properties from the registry asyncronously.
/// </summary>
public virtual async Task LoadAsync()
{
ShellSettingsManager manager = await _settingsManager.GetValueAsync();
SettingsStore settingsStore = manager.GetReadOnlySettingsStore(SettingsScope.UserSettings);
HashSet <string> testedCollections = new HashSet <string>();
bool DoesCollectionExist(string collectionName)
{
if (testedCollections.Contains(collectionName))
{
return(true);
}
if (settingsStore.CollectionExists(collectionName))
{
testedCollections.Add(collectionName);
return(true);
}
return(false);
}
foreach (PropertyInfo property in GetOptionProperties())
{
try
{
var collectionNameAttribute = property.GetCustomAttribute <OverrideCollectionNameAttribute>();
var collectionName = collectionNameAttribute?.CollectionName ?? this.CollectionName;
if (!DoesCollectionExist(collectionName))
{
continue;
}
var overrideDataTypeAttribute = property.GetCustomAttribute <OverrideDataTypeAttribute>();
var dataType = overrideDataTypeAttribute?.SettingDataType ?? SettingDataType.Serialized;
switch (dataType)
{
case SettingDataType.Serialized:
var serializedProp = settingsStore.GetString(collectionName, property.Name, default);
var value = DeserializeValue(serializedProp, property.PropertyType);
property.SetValue(this, value);
break;
case SettingDataType.Bool:
var boolValue = settingsStore.GetBoolean(collectionName, property.Name, false);
property.SetValue(this, boolValue);
break;
default:
throw new ArgumentOutOfRangeException();
}
}
catch
{
// Do nothing here
}
}
}
internal static bool TryGetInt(this SettingsStore settingsStore, string collectionName, string propertyName, out int value)
{
if (settingsStore.CollectionExists(collectionName))
{
value = settingsStore.GetInt32(collectionName, propertyName);
return(true);
}
value = default;
return(false);
}
public ServerParameters()
{
SettingsManager settingsManager = new ShellSettingsManager(VMSTPSettingsStore.ServiceProvider);
SettingsStore configurationSettingsStore = settingsManager.GetReadOnlySettingsStore(SettingsScope.UserSettings);
if (configurationSettingsStore.CollectionExists(VMSTPSettingsStore.Collection))
{
disableESMTP = configurationSettingsStore.GetBoolean(VMSTPSettingsStore.Collection, "DisableESMTP", DisableESMTP);
port = configurationSettingsStore.GetInt32(VMSTPSettingsStore.Collection, "Port", Port);
}
}
private static string GetStringOption(SettingsStore store, string catelogName, string optionName)
{
if (store == null ||
!store.CollectionExists(COLLECTION_PATH) ||
!store.PropertyExists(COLLECTION_PATH, CombineCatelogAndOptionName(catelogName, optionName)))
{
return(null);
}
return(store.GetString(COLLECTION_PATH, CombineCatelogAndOptionName(catelogName, optionName)));
}
private void InstructionOptionLoad(SettingsStore settingsStore)
{
if (!settingsStore.CollectionExists(InstructionCollectionName))
{
return;
}
_generalOptionProvider.InstructionsPaths = ReadSetting <IReadOnlyList <string> >(
settingsStore, InstructionCollectionName,
nameof(_generalOptionProvider.InstructionsPaths));
}
private static Color?GetColorOption(SettingsStore store, string catelogName, string optionName)
{
if (store == null ||
!store.CollectionExists(COLLECTION_PATH) ||
!store.PropertyExists(COLLECTION_PATH, CombineCatelogAndOptionName(catelogName, optionName)))
{
return(null);
}
var rgb = store.GetString(COLLECTION_PATH, CombineCatelogAndOptionName(catelogName, optionName)).Split(',').Select(x => Int32.Parse(x)).ToList();
return(Color.FromArgb(rgb[0], rgb[1], rgb[2]));
}
/// <summary>
/// Hydrates the properties from the registry asyncronously.
/// </summary>
public virtual async Task LoadAsync()
{
ShellSettingsManager manager = await _settingsManager.GetValueAsync().ConfigureAwait(true);
SettingsStore settingsStore = manager.GetReadOnlySettingsStore(SettingsScope.UserSettings);
if (!settingsStore.CollectionExists(CollectionName))
{
return;
}
#if DEBUG_OPTION_VALUES_LOAD_SAVE
Debug.WriteLine($"LoadAsync<{typeof(T).Name}>()");
Debug.WriteLine($"GetPropertyCount = {settingsStore.GetPropertyCount(CollectionName)}");
Debug.WriteLine($"GetPropertyCount = {settingsStore.GetPropertyCount(CollectionName)}");
//var pnv = settingsStore.GetPropertyNamesAndValues(CollectionName);
var pn = settingsStore.GetPropertyNames(CollectionName);
foreach (var n in pn)
{
Debug.WriteLine($"Property: Name={n} Type = {settingsStore.GetPropertyType(CollectionName, n).ToString()}");
}
#endif
var propertiesToSerialize = GetOptionProperties();
foreach (PropertyInfo property in propertiesToSerialize)
{
if (!settingsStore.PropertyExists(CollectionName, property.Name))
{
#if DEBUG_OPTION_VALUES_LOAD_SAVE
Debug.WriteLine($"Skipping property {property.Name}. Not found in settings store");
#endif
property.SetValue(this, property.GetValue(this));
continue;
}
try
{
string serializedProp = settingsStore.GetString(CollectionName, property.Name);
object value = DeserializeValue(serializedProp, property.PropertyType);
property.SetValue(this, value);
#if DEBUG_OPTION_VALUES_LOAD_SAVE
Debug.WriteLine($"{property.Name} = {property.GetValue(this)} | value = {value}");
#endif
}
catch (Exception ex)
{
System.Diagnostics.Debug.WriteLine(ex);
}
}
#if DEBUG_OPTION_VALUES_LOAD_SAVE
Debug.WriteLine($"LoadAsync<{typeof(T).Name}>() finished ===================================");
#endif
}
public AutoLoadPackage(Guid packageGuid, Guid contextGuid, string contextName, bool isRuleBasedUIContext, string contextTerms, SettingsStore configurationStore)
{
PackageGuid = packageGuid;
AutoLoadContextGuid = contextGuid;
AutoLoadContextName = contextName;
IsRuleBasedUIContext = isRuleBasedUIContext;
UIContextTerms = contextTerms;
string packageInfoPath = Path.Combine(_packagesPath, packageGuid.ToString("B"));
string autoLoadConfigurationPath = Path.Combine(_autoLoadPackagesPath, contextGuid.ToString("B"));
if (configurationStore.CollectionExists(packageInfoPath))
{
PackageName = configurationStore.GetString(packageInfoPath, string.Empty, "Unknown").Split(',')[0];
string moduleName = configurationStore.GetString(packageInfoPath, "Class", null) ?? Path.GetFileName(configurationStore.GetString(packageInfoPath, "InProcServer32", string.Empty));
ModuleName = moduleName.Split(',')[0];
IsAsyncPackage = configurationStore.GetBoolean(packageInfoPath, "AllowsBackgroundLoad", false);
}
if (configurationStore.CollectionExists(autoLoadConfigurationPath))
{
uint autoLoadFlags = (uint)PackageAutoLoadFlags.None;
try
{
autoLoadFlags = configurationStore.GetUInt32(autoLoadConfigurationPath, packageGuid.ToString("B"), 0);
}
catch (Exception)
{
//Do not do anyting. Use none as flag
// Apparently user feed package "bb4bf712-fcf7-4d17-83bb-93e6478b4e5d" specified a string in the pkgdef..
}
bool backgroundLoad = ((autoLoadFlags & (uint)PackageAutoLoadFlags.BackgroundLoad) == (uint)PackageAutoLoadFlags.BackgroundLoad);
IsAsyncForUIContext = IsAsyncPackage && backgroundLoad;
}
}
public void WriteInt32(string name, int value)
{
if (_serviceProvider == null)
{
return;
}
int exists;
SettingsStore.CollectionExists(SettingsRoot, out exists);
if (exists != 1)
{
SettingsStore.CreateCollection(SettingsRoot);
}
SettingsStore.SetInt(SettingsRoot, name, value);
}
private void SetSettings(string container, string vsdbg)
{
const string collectionPath = nameof(AttachToDockerContainerDialog);
ThreadHelper.ThrowIfNotOnUIThread();
SettingsStore.CollectionExists(collectionPath, out int exists);
if (exists != 1)
{
SettingsStore.CreateCollection(collectionPath);
}
SettingsStore.SetString(collectionPath, "container", container);
SettingsStore.SetString(collectionPath, "vsdbg", vsdbg);
}
//=====================================================================
/// <summary>
/// This is used to load the MEF provider configuration settings
/// </summary>
/// <returns>True if loaded successfully or false if the settings collection does not exist</returns>
/// <remarks>The settings are loaded using the <see cref="ShellSettingsManager"/> from the
/// <see cref="CollectionPath"/> collection.</remarks>
private bool LoadConfiguration()
{
ShellSettingsManager settingsManager = new ShellSettingsManager(_serviceProvider);
SettingsStore settingsStore = settingsManager.GetReadOnlySettingsStore(SettingsScope.UserSettings);
if (!settingsStore.CollectionExists(CollectionPath))
{
return(false);
}
EnableExtendedXmlCommentsCompletion = settingsStore.GetBoolean(CollectionPath, "EnableExtendedXmlCommentsCompletion", true);
EnableGoToDefinition = settingsStore.GetBoolean(CollectionPath, "EnableGoToDefinition", true);
EnableGoToDefinitionInCRef = settingsStore.GetBoolean(CollectionPath, "EnableGoToDefinitionInCRef", DefaultEnableGoToDefinitionInCRef);
return(true);
}
/// <summary>
/// Hydrates the properties from the registry asyncronously.
/// </summary>
public virtual async Task LoadAsync()
{
ShellSettingsManager manager = await s_settings_manager.GetValueAsync();
if (manager == null)
{
return;
}
SettingsStore settingsStore = manager.GetReadOnlySettingsStore(SettingsScope.UserSettings);
if (settingsStore == null)
{
return;
}
if (!settingsStore.CollectionExists(CollectionName))
{
return;
}
LoadProperty(settingsStore);
}
private PythonInterpreterFactoryWithDatabase LoadUserDefinedInterpreter(SettingsStore store, string guid)
{
// PythonInterpreters\
// Id\
// Description
// InterpreterPath
// WindowsInterpreterPath
// Architecture
// Version
// PathEnvironmentVariable
Guid id;
string collection;
if (Guid.TryParse(guid, out id) && store.CollectionExists((collection = PythonInterpreterKey + "\\" + id.ToString("B"))))
{
var path = store.GetString(collection, PathKey, string.Empty);
var winPath = store.GetString(collection, WindowsPathKey, string.Empty);
var libPath = store.GetString(collection, LibraryPathKey, string.Empty);
var arch = store.GetString(collection, ArchitectureKey, string.Empty);
var version = store.GetString(collection, VersionKey, string.Empty);
var pathEnvVar = store.GetString(collection, PathEnvVarKey, string.Empty);
var description = store.GetString(collection, DescriptionKey, string.Empty);
return(InterpreterFactoryCreator.CreateInterpreterFactory(
new InterpreterFactoryCreationOptions {
LanguageVersionString = version,
Id = id,
Description = description,
InterpreterPath = path,
WindowInterpreterPath = winPath,
LibraryPath = libPath,
PathEnvironmentVariableName = pathEnvVar,
ArchitectureString = arch,
WatchLibraryForNewModules = true
}
));
}
return(null);
}
private PythonInterpreterFactoryWithDatabase LoadUserDefinedInterpreter(SettingsStore store, string guid) {
// PythonInterpreters\
// Id\
// Description
// InterpreterPath
// WindowsInterpreterPath
// Architecture
// Version
// PathEnvironmentVariable
Guid id;
string collection;
if (Guid.TryParse(guid, out id) && store.CollectionExists((collection = PythonInterpreterKey + "\\" + id.ToString("B")))) {
var path = store.GetString(collection, PathKey, string.Empty);
var winPath = store.GetString(collection, WindowsPathKey, string.Empty);
var libPath = store.GetString(collection, LibraryPathKey, string.Empty);
var arch = store.GetString(collection, ArchitectureKey, string.Empty);
var version = store.GetString(collection, VersionKey, string.Empty);
var pathEnvVar = store.GetString(collection, PathEnvVarKey, string.Empty);
var description = store.GetString(collection, DescriptionKey, string.Empty);
return InterpreterFactoryCreator.CreateInterpreterFactory(
new InterpreterFactoryCreationOptions {
LanguageVersionString = version,
Id = id,
Description = description,
InterpreterPath = path,
WindowInterpreterPath = winPath,
LibraryPath = libPath,
PathEnvironmentVariableName = pathEnvVar,
ArchitectureString = arch,
WatchLibraryForNewModules = true
}
);
}
return null;
}
public override void LoadSettingsFromStorage()
{
SettingsManager settingsManager = new ShellSettingsManager(ServiceProvider.GlobalProvider);
SettingsStore settingsStore = settingsManager.GetReadOnlySettingsStore(SettingsScope.UserSettings);
if (!settingsStore.CollectionExists(CollectionName))
{
return;
}
foreach (PropertyInfo property in GetOptionProperties())
{
try
{
string serializedProp = settingsStore.GetString(CollectionName, property.Name);
object value = DeserializeValue(serializedProp, property.PropertyType);
property.SetValue(this, value);
}
catch (Exception ex)
{
System.Diagnostics.Debug.Write(ex);
}
}
}
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());
}
public int CollectionExists([ComAliasName("OLE.LPCOLESTR")] string collectionPath, [ComAliasName("OLE.BOOL")] out int pfExists)
{
pfExists = inner.CollectionExists(collectionPath) ? 1 : 0;
return(0);
}
/// <summary>
/// Populates the maps that map from name -> scope info and GUID -> scope info
/// </summary>
private void PopulateScopeMaps()
{
ShellSettingsManager settingsManager = new ShellSettingsManager(this.serviceProvider);
SettingsStore settingsStore = settingsManager.GetReadOnlySettingsStore(SettingsScope.Configuration);
// First build map of all registered scopes
if (settingsStore.CollectionExists(KeyBindingTableRegKeyName))
{
int itemCount = settingsStore.GetSubCollectionCount(KeyBindingTableRegKeyName);
foreach (string str in settingsStore.GetSubCollectionNames(KeyBindingTableRegKeyName))
{
string collectionName = Path.Combine(KeyBindingTableRegKeyName, str);
Guid scopeId;
if (!Guid.TryParse(str, out scopeId))
{
continue;
}
Guid owningPackage;
uint resourceId;
bool allowNavKeyBinding = false;
if (scopeId == VSConstants.GUID_VSStandardCommandSet97)
{
owningPackage = CLSID_VsEnvironmentPackage;
resourceId = ID_Intl_Base + 18;
}
else
{
if (!settingsStore.PropertyExists(collectionName, PackageRegPropertyName))
{
continue;
}
if (!Guid.TryParse(settingsStore.GetString(collectionName, PackageRegPropertyName), out owningPackage))
{
continue;
}
string resIdString = settingsStore.GetString(collectionName, string.Empty);
if (resIdString.StartsWith("#"))
{
resIdString = resIdString.Substring(1);
}
if (!uint.TryParse(resIdString, out resourceId))
{
continue;
}
if (settingsStore.PropertyExists(collectionName, AllowNavKeyBindingPropertyName))
{
allowNavKeyBinding = settingsStore.GetUInt32(collectionName, AllowNavKeyBindingPropertyName) == 0 ? false : true;
}
}
string scopeName;
if (!ErrorHandler.Succeeded(Shell.LoadPackageString(ref owningPackage, resourceId, out scopeName)))
{
continue;
}
KeybindingScope scopeInfo = new KeybindingScope(scopeName, scopeId, allowNavKeyBinding);
this.scopeGuidToScopeInfoMap[scopeId] = scopeInfo;
this.scopeNameToScopeInfoMap[scopeName] = scopeInfo;
}
}
IVsEnumGuids scopeEnum = UIShell.EnumKeyBindingScopes();
// Random GUID the shell also skips ("Source Code Text Editor" scope)
Guid toSkip = new Guid("{72F42A10-B1C5-11d0-A8CD-00A0C921A4D2}");
Guid[] scopes = new Guid[1];
uint fetched = 0;
while (scopeEnum.Next((uint)scopes.Length, scopes, out fetched) == VSConstants.S_OK && fetched != 0)
{
// We already have info for this scope
if (scopeGuidToScopeInfoMap.ContainsKey(scopes[0]))
{
continue;
}
// The shell skips this as a possible binding scope
if (scopes[0] == toSkip)
{
continue;
}
string path = Path.Combine("Editors", scopes[0].ToString("B"));
// If it isn't a registered scope, see if it is an editor factory
if (!settingsStore.CollectionExists(path))
{
continue;
}
if (!settingsStore.PropertyExists(path, PackageRegPropertyName))
{
continue;
}
Guid packageGuid;
if (!Guid.TryParse(settingsStore.GetString(path, PackageRegPropertyName), out packageGuid))
{
continue;
}
if (!settingsStore.PropertyExists(path, DisplayNameRegPropertyName))
{
continue;
}
string displayNameResIdStr = settingsStore.GetString(path, DisplayNameRegPropertyName);
if (displayNameResIdStr.StartsWith("#"))
{
displayNameResIdStr = displayNameResIdStr.Substring(1);
}
uint displayNameResId;
if (!uint.TryParse(displayNameResIdStr, out displayNameResId))
{
continue;
}
string displayName;
if (!ErrorHandler.Succeeded(shell.LoadPackageString(ref packageGuid, displayNameResId, out displayName)))
{
continue;
}
// NOTE: Is false the right default value?
KeybindingScope scopeInfo = new KeybindingScope(displayName, scopes[0], allowNavKeyBinding: false);
this.scopeGuidToScopeInfoMap[scopes[0]] = scopeInfo;
this.scopeNameToScopeInfoMap[displayName] = scopeInfo;
}
}
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();
}
private bool IsRuleBasedUIContext(string uiContextString)
{
return(_configurationStore.CollectionExists(Path.Combine(_uIContextRulesPath, uiContextString)));
}
