/// <summary>
/// Writes a value 1 in the registrykey and as aresult the dont show again dialog will not be launched.
/// </summary>
/// <param name="registryKey">The key to write to.</param>
/// <param name="value">The value to write.</param>
internal static void WriteDontShowAgainValue(string registryKey, int value)
{
using (RegistryKey root = VSRegistry.RegistryRoot(__VsLocalRegistryType.RegType_UserSettings))
{
if (root != null)
{
using (RegistryKey key = root.OpenSubKey(GeneralSubKey, true))
{
key.SetValue(registryKey, value, RegistryValueKind.DWord);
}
}
}
}
internal static string LoadString(string name, string cat)
{
using (var nodeKey = VSRegistry.RegistryRoot(__VsLocalRegistryType.RegType_UserSettings, true).CreateSubKey(NodejsConstants.BaseRegistryKey))
{
using (var optionsKey = nodeKey.CreateSubKey(_optionsKey))
{
using (var categoryKey = optionsKey.CreateSubKey(cat))
{
return(categoryKey.GetValue(name) as string);
}
}
}
}
internal static void SaveString(string name, string value, string cat)
{
using (var pythonKey = VSRegistry.RegistryRoot(__VsLocalRegistryType.RegType_UserSettings, true).CreateSubKey(NodejsConstants.BaseRegistryKey))
{
using (var optionsKey = pythonKey.CreateSubKey(_optionsKey))
{
using (var categoryKey = optionsKey.CreateSubKey(cat))
{
categoryKey.SetValue(name, value, Win32.RegistryValueKind.String);
}
}
}
}
private void addOurFileExtensionsForDiffAndPeek(string parent)
{
using (RegistryKey root = VSRegistry.RegistryRoot(__VsLocalRegistryType.RegType_Configuration, true))
{
if (root != null)
{
using (RegistryKey key = root.OpenSubKey(parent, true))
{
key.SetValue(EXTENSIONS, "");
}
}
}
}
/// <summary>
/// Get the color scheme that is applied to the configuration registry.
/// </summary>
public SchemeName GetAppliedColorScheme()
{
// The applied color scheme is stored in the configuration registry with the color theme information because
// when the hive gets rebuilt during upgrades, we need to reapply the color scheme information.
using var registryRoot = VSRegistry.RegistryRoot(
_serviceProvider,
__VsLocalRegistryType.RegType_Configuration,
writable: false
);
using var itemKey = registryRoot.OpenSubKey(ColorSchemeApplierKey);
return(itemKey is object
?(SchemeName)itemKey.GetValue(AppliedColorSchemeName)
: default);
public static bool InstallDebugger(IMessageLogger msg, bool force = false)
{
try
{
if (CheckInstalled() && !force) //Check if the debugger is already installed
{
return(true);
}
string location = typeof(MonoEngine).Assembly.Location;
//Register the debugger assembly
string regasm = @"C:\Windows\Microsoft.NET\Framework64\v4.0.30319\RegAsm.exe";
if (!Environment.Is64BitOperatingSystem)
{
regasm = @"C:\Windows\Microsoft.NET\Framework\v4.0.30319\RegAsm.exe";
}
var p = new ProcessStartInfo(regasm, location);
p.Verb = "runas";
p.RedirectStandardOutput = true;
p.UseShellExecute = false;
p.CreateNoWindow = true;
Process proc = Process.Start(p);
proc.WaitForExit();
if (proc.ExitCode != 0)
{
throw new UnauthorizedAccessException();
}
//Add the regsitry stuff for VS
using (RegistryKey config = VSRegistry.RegistryRoot(__VsLocalRegistryType.RegType_Configuration))
{
RegisterDebugEngine(location, config);
}
return(true);
}
catch (UnauthorizedAccessException)
{
msg.ErrorMessage("Unable to install " + DebuggerGuids.EngineName + " - Please run Visual Studio as administrator.", "Debugger installation");
}
catch (Exception ex)
{
msg.ErrorMessage("An error ocurred while installing " + DebuggerGuids.EngineName + ": \"" + ex.Message + "\"", "Debugger installation");
}
return(false);
}
Guid FindGuid()
{
try
{
using (var settings = VSRegistry.RegistryRoot(__VsLocalRegistryType.RegType_Configuration))
using (var languages = settings.OpenSubKey("Languages"))
using (var intellisenseProviders = languages.OpenSubKey("IntellisenseProviders"))
using (var provider = intellisenseProviders.OpenSubKey(ProviderName))
return(new Guid(provider.GetValue("GUID").ToString()));
}
catch
{
return(Guid.Empty);
}
}
private static IRegistryKey OpenRegistry(bool writeable)
{
if (OverrideRegistryKey != null)
{
return(OverrideRegistryKey);
}
var root = VSRegistry.RegistryRoot(__VsLocalRegistryType.RegType_UserSettings, writeable);
var subKey = writeable
? root.CreateSubKey(RegistryPath)
: root.OpenSubKey(RegistryPath);
return((subKey != null) ? new RegistryKeyImpl(subKey) : null);
}
public void ApplyColorScheme(SchemeName schemeName, ImmutableArray <RegistryItem> registryItems)
{
using var registryRoot = VSRegistry.RegistryRoot(_serviceProvider, __VsLocalRegistryType.RegType_Configuration, writable: true);
foreach (var item in registryItems)
{
using var itemKey = registryRoot.CreateSubKey(item.SectionName);
itemKey.SetValue(item.ValueName, item.ValueData);
}
_workspace.SetOptions(_workspace.Options.WithChangedOption(ColorSchemeOptions.AppliedColorScheme, schemeName));
// Broadcast that system color settings have changed to force the ColorThemeService to reload colors.
NativeMethods.PostMessage(NativeMethods.HWND_BROADCAST, NativeMethods.WM_SYSCOLORCHANGE, wparam: IntPtr.Zero, lparam: IntPtr.Zero);
}
/// <summary>
/// Get the localized names of "Global", "Text Editor" and "Solution Explorer" scope. I wish there was a
/// prettier way of doing this. However there is no API available which provides this information. We need to directly
/// query some registry values here
/// </summary>
private static bool TryGetMainScopeNames(IVsShell vsShell, out string globalScopeName, out string textEditorScopeName, out string solutionExplorerScopeName)
{
globalScopeName = null;
textEditorScopeName = null;
solutionExplorerScopeName = null;
try
{
using (var rootKey = VSRegistry.RegistryRoot(__VsLocalRegistryType.RegType_Configuration, writable: false))
{
if (rootKey is null)
{
return(false);
}
using (var keyBindingsKey = rootKey.OpenSubKey("KeyBindingTables"))
{
// For "Global". The id in the registry here is incorrect for Vs 2010+
// so hard code the known value
if (!TryGetKeyBindingScopeName(vsShell, keyBindingsKey, "{5efc7975-14bc-11cf-9b2b-00aa00573819}", 13018, out globalScopeName))
{
return(false);
}
// For "Text Editor". Many locals don't define this key so it's still considered a success
// if we get only the global name. Just fill in the default here
if (!TryGetKeyBindingScopeName(vsShell, keyBindingsKey, "{8B382828-6202-11D1-8870-0000F87579D2}", null, out textEditorScopeName))
{
textEditorScopeName = DefaultTextEditorScopeName;
}
// The "Solution Explorer" scope is only relevant starting in VS2013. By default it contains a lot of
// key bindings for '['. If we can't find the real name just use the default. We don't want its abscence
// to screw up other scopes
if (!TryGetKeyBindingScopeName(vsShell, keyBindingsKey, "{3AE79031-E1BC-11D0-8F78-00A0C9110057}", null, out solutionExplorerScopeName))
{
solutionExplorerScopeName = DefaultSolutionExplorerScopeName;
}
}
}
return(true);
}
catch (Exception)
{
return(false);
}
}
private void TryRegisterAssembly()
{
try
{
RegistryKey regKey = Registry.ClassesRoot.OpenSubKey(@"CLSID\{8BF3AB9F-3864-449A-93AB-E7B0935FC8F5}");
if (regKey != null)
{
return;
}
string location = typeof(DebuggedProcess).Assembly.Location;
string regasm = @"C:\Windows\Microsoft.NET\Framework64\v4.0.30319\RegAsm.exe";
if (!Environment.Is64BitOperatingSystem)
{
regasm = @"C:\Windows\Microsoft.NET\Framework\v4.0.30319\RegAsm.exe";
}
var p = new ProcessStartInfo(regasm, location);
p.Verb = "runas";
p.RedirectStandardOutput = true;
p.UseShellExecute = false;
p.CreateNoWindow = true;
Process proc = Process.Start(p);
while (!proc.HasExited)
{
string txt = proc.StandardOutput.ReadToEnd();
}
using (RegistryKey config = VSRegistry.RegistryRoot(__VsLocalRegistryType.RegType_Configuration))
{
MonoRemoteDebuggerInstaller.RegisterDebugEngine(location, config);
}
}
catch (UnauthorizedAccessException)
{
MessageBox.Show(
"Failed finish installation of MonoRemoteDebugger - Please run Visual Studio once als Administrator...",
"MonoRemoteDebugger", MessageBoxButton.OK, MessageBoxImage.Error);
}
catch (Exception ex)
{
logger.Error(ex);
}
}
private bool CheckKey(string editor, string extension)
{
var root = VSRegistry.RegistryRoot(__VsLocalRegistryType.RegType_Configuration);
var reg = root.OpenSubKey("editors\\" + editor + "\\Extensions");
bool Ok = true;
if (reg != null)
{
object value = reg.GetValue(extension);
if (value is int && (int)value >= 0x42)
{
Ok = false;
}
reg.Close();
}
return(Ok);
}
public static bool IsTestAdapaterEnabled()
{
if (!checkedRegistryForTestAdapterEnabled)
{
using (var nodeKey = VSRegistry.RegistryRoot(__VsLocalRegistryType.RegType_UserSettings, true).CreateSubKey(NodejsConstants.BaseRegistryKey))
using (var optionsKey = nodeKey.CreateSubKey("Options"))
using (var categoryKey = optionsKey.CreateSubKey("testing"))
{
// If the value is set to something we disable this testadapter
registryValueForTestAdapterEnabled = string.IsNullOrEmpty(categoryKey.GetValue("testadapter") as string);
}
checkedRegistryForTestAdapterEnabled = true;
}
return(registryValueForTestAdapterEnabled);
}
bool ITextTemplatingEngineHost.LoadIncludeText(string requestFileName, out string content, out string location)
{
location = ((ITextTemplatingEngineHost)this).ResolvePath(requestFileName);
if (File.Exists(location))
{
content = File.ReadAllText(location);
return(true);
}
using (var rootKey = VSRegistry.RegistryRoot(__VsLocalRegistryType.RegType_Configuration))
using (var includeFoldersKey = rootKey.OpenSubKey(@"TextTemplating\IncludeFolders\.tt"))
{
foreach (var valueName in includeFoldersKey.GetValueNames())
{
var includeFolder = includeFoldersKey.GetValue(valueName) as string;
if (includeFolder == null)
{
continue;
}
location = Path.Combine(includeFolder, requestFileName);
if (File.Exists(location))
{
content = File.ReadAllText(location);
// Our implementation doesn't require respecting the CleanupBehavior custom directive, and since
// implementing a fallback custom directive processor would essencially force us to have two
// different versions of the EF Power Tools (one for VS 2010, another one for VS 2012) the simplest
// solution is to remove the custom directive from the in-memory copy of the ttinclude
content = content.Replace(@"<#@ CleanupBehavior Processor=""T4VSHost"" CleanupAfterProcessingTemplate=""true"" #>", "");
return(true);
}
}
}
location = string.Empty;
content = string.Empty;
return(false);
}
internal static bool ShouldUseV3CdpDebugger()
{
var userRegistryRoot = VSRegistry.RegistryRoot(__VsLocalRegistryType.RegType_UserSettings, writable: false);
try
{
object userDebuggerOption = userRegistryRoot.OpenSubKey("Debugger")?.GetValue("EnableJavaScriptMultitargetNodeDebug");
if (userDebuggerOption is int optionVal)
{
return(optionVal != 0);
}
}
catch (Exception) { } // do nothing. proceed to trying the feature flag below.
var featureFlagsService = (IVsFeatureFlags)ServiceProvider.GlobalProvider.GetService(typeof(SVsFeatureFlags));
return(featureFlagsService is IVsFeatureFlags && featureFlagsService.IsFeatureEnabled("JavaScript.Debugger.V3CdpNodeDebugAdapter", false));
}
/// <summary>
/// Called after Visual Studio services are available, before the frame is created (this.Frame can be null)
/// </summary>
protected override void Initialize()
{
ThreadHelper.ThrowIfNotOnUIThread();
this.package.Telemetry.TrackEvent(Constants.EventInitializePane);
// Look up the value of WPF trace settings in the registry
using (RegistryKey rootKey = VSRegistry.RegistryRoot(this, __VsLocalRegistryType.RegType_UserSettings, writable: true))
{
this.dataBindingOutputLevelKey = rootKey.CreateSubKey(Constants.DataBindingTraceKey, writable: true);
}
this.HookDataBindingTraceLevel();
this.HookDebugEvents();
this.WaitForDebugOutputTextBuffer();
base.Initialize();
}
/// <summary>
/// Reads a boolean value specifying whether to show or not show the dialog
/// </summary>
/// <param name="registryKey">The key containing the value.</param>
/// <returns>The value read. If the value cannot be read false is returned.</returns>
internal static bool ReadDontShowAgainValue(string registryKey)
{
bool dontShowAgain = false;
using (RegistryKey root = VSRegistry.RegistryRoot(__VsLocalRegistryType.RegType_UserSettings))
{
if (root != null)
{
using (RegistryKey key = root.OpenSubKey(GeneralSubKey))
{
int value = (int)key.GetValue(registryKey, 0);
dontShowAgain = (value != 0);
}
}
}
return(dontShowAgain);
}
protected System.Drawing.Color UpdateColorSetting(string name, System.Drawing.Color defaultColor)
{
using (var regKey = VSRegistry.RegistryRoot(__VsLocalRegistryType.RegType_UserSettings))
{
if (regKey == null)
{
return(defaultColor);
}
using (var colorKey = regKey.OpenSubKey(PROP_LOCATION))
{
if (colorKey == null)
{
return(defaultColor);
}
var prop = colorKey.GetValue(name) as string;
if (prop == null)
{
return(defaultColor);
}
try
{
BlackSpaceColorConverter cc = new BlackSpaceColorConverter();
object Obj = cc.ConvertFromString(prop);
if (Obj != null && Obj is System.Drawing.Color)
{
System.Drawing.Color color = (System.Drawing.Color)Obj;
if (!color.IsEmpty)
{
return(color);
}
}
}
catch (Exception e)
{
System.Console.WriteLine(e.Message);
return(defaultColor);
}
return(defaultColor);
}
}
}
public static IEnumerable <ColumnState> LoadSettings(string window, IEnumerable <ColumnState> defaultColumns)
{
var columns = new List <Tuple <int, ColumnState> >();
using (var rootKey = VSRegistry.RegistryRoot(ProjectSystemToolsPackage.ServiceProvider, __VsLocalRegistryType.RegType_UserSettings, writable: false))
{
using (var columnsSubKey = rootKey.OpenSubKey(CreateColumnsKey(window), writable: false))
{
if (columnsSubKey == null)
{
return(defaultColumns);
}
foreach (var columnName in columnsSubKey.GetSubKeyNames())
{
using (var columnSubKey = columnsSubKey.OpenSubKey(columnName, writable: false))
{
if (columnSubKey == null)
{
continue;
}
var descendingSort = (int)columnSubKey.GetValue(ColumnSortDown, 1) != 0;
var sortPriority = (int)columnSubKey.GetValue(ColumnSortPriority, 0);
var groupingPriority = (int)columnSubKey.GetValue(ColumnGroupingPriority, 0);
var columnOrder = (int)columnSubKey.GetValue(ColumnOrder, int.MaxValue);
var visibility = (int)columnSubKey.GetValue(ColumnVisibility, 0) != 0;
var width = (int)columnSubKey.GetValue(ColumnWidth, 20);
var state = new ColumnState2(columnName, visibility, width, sortPriority, descendingSort, groupingPriority);
columns.Add(new Tuple <int, ColumnState>(columnOrder, state));
}
}
}
}
columns.Sort((a, b) => a.Item1 - b.Item1);
return(columns.Select(a => a.Item2));
}
private void InitializeRegistrySettings()
{
using (var textEditor = VSRegistry.RegistryRoot(__VsLocalRegistryType.RegType_UserSettings, true).CreateSubKey("Text Editor")) {
using (var ironRubyKey = textEditor.CreateSubKey(RubyConstants.TextEditorSettingsRegistryKey)) {
object curValue;
curValue = ironRubyKey.GetValue("Insert Tabs");
if (curValue == null)
{
ironRubyKey.SetValue("Insert Tabs", 0);
}
curValue = ironRubyKey.GetValue("Indent Size");
if (curValue == null)
{
ironRubyKey.SetValue("Indent Size", 2);
}
}
}
}
public static bool SaveSettings(string window, IWpfTableControl control)
{
var columns = control.ColumnStates;
using (var rootKey = VSRegistry.RegistryRoot(ProjectSystemToolsPackage.ServiceProvider, __VsLocalRegistryType.RegType_UserSettings, writable: true))
{
using (var columnsSubKey = rootKey.CreateSubKey(CreateColumnsKey(window)))
{
if (columnsSubKey == null)
{
return(false);
}
for (var i = 0; i < columns.Count; i++)
{
var column = columns[i];
using (var columnSubKey = columnsSubKey.CreateSubKey(column.Name))
{
if (columnSubKey == null)
{
continue;
}
columnSubKey.SetValue(ColumnOrder, i, RegistryValueKind.DWord);
columnSubKey.SetValue(ColumnVisibility, column.IsVisible ? 1 : 0, RegistryValueKind.DWord);
columnSubKey.SetValue(ColumnWidth, (int)column.Width, RegistryValueKind.DWord);
columnSubKey.SetValue(ColumnSortDown, column.DescendingSort ? 1 : 0, RegistryValueKind.DWord);
columnSubKey.SetValue(ColumnSortPriority, column.SortPriority, RegistryValueKind.DWord);
if (column is ColumnState2 cs2)
{
columnSubKey.SetValue(ColumnGroupingPriority, cs2.GroupingPriority, RegistryValueKind.DWord);
}
}
}
}
}
return(true);
}
internal static string LoadString(string name, string cat)
{
using (var pythonKey = VSRegistry.RegistryRoot(__VsLocalRegistryType.RegType_UserSettings, true).CreateSubKey(VSGeneroConstants.BaseRegistryKey))
{
if (pythonKey == null)
{
return(null);
}
using (var optionsKey = pythonKey.CreateSubKey(_optionsKey))
{
if (optionsKey == null)
{
return(null);
}
using (var categoryKey = optionsKey.CreateSubKey(cat)) {
return(categoryKey?.GetValue(name) as string);
}
}
}
}
private static string LoadString(string name)
{
using (var pythonKey = VSRegistry.RegistryRoot(__VsLocalRegistryType.RegType_UserSettings, true).CreateSubKey(VSGeneroConstants.BaseRegistryKey))
{
if (pythonKey == null)
{
return(null);
}
using (var refactorKey = pythonKey.CreateSubKey(RefactorKey))
{
if (refactorKey == null)
{
return(null);
}
using (var renameKey = refactorKey.CreateSubKey(RenameKey))
{
return(renameKey?.GetValue(name) as string);
}
}
}
}
private string LoadStringInternal(string name, string cat)
{
using (var regKey = VSRegistry.RegistryRoot(__VsLocalRegistryType.RegType_UserSettings, true).CreateSubKey(_baseKey))
{
if (regKey == null)
{
return(null);
}
using (var optionsKey = regKey.CreateSubKey(_optionsKey))
{
if (optionsKey == null)
{
return(null);
}
using (var categoryKey = optionsKey.CreateSubKey(cat))
{
return(categoryKey?.GetValue(name) as string);
}
}
}
}
internal static bool ShouldUseV3CdpDebugger()
{
var userRegistryRoot = VSRegistry.RegistryRoot(__VsLocalRegistryType.RegType_UserSettings, writable: false);
try
{
object userDebuggerOption = userRegistryRoot.OpenSubKey("Debugger")?.GetValue("EnableJavaScriptMultitargetDebugging");
if (userDebuggerOption == null)
{
return(false);
}
else
{
return((int)userDebuggerOption != 0);
}
}
catch (Exception)
{
return(false);
}
}
public static void TryRegisterAssembly()
{
// TODO move to AdapterRegistration.pkgdef
// see https://github.com/microsoft/VSDebugAdapterHost/blob/master/src/sample/SampleDebugAdapter.VSIX/AdapterRegistration.pkgdef
// see https://github.com/Microsoft/VSDebugAdapterHost/wiki
// see https://github.com/microsoft/VSDebugAdapterHost/wiki/Packaging-a-VS-Code-Debug-Adapter-For-Use-in-VS
RegistryKey regKey = Registry.ClassesRoot.OpenSubKey($@"CLSID\{{{DebugEngineGuids.EngineGuid.ToString()}}}");
if (regKey != null)
{
return; // Already registered
}
string location = typeof(XamarinEngine).Assembly.Location;
string regasm = @"C:\Windows\Microsoft.NET\Framework64\v4.0.30319\RegAsm.exe";
if (!Environment.Is64BitOperatingSystem)
{
regasm = @"C:\Windows\Microsoft.NET\Framework\v4.0.30319\RegAsm.exe";
}
var regasmProcessStartInfo = new ProcessStartInfo(regasm, location);
regasmProcessStartInfo.Verb = "runas";
regasmProcessStartInfo.RedirectStandardOutput = true;
regasmProcessStartInfo.UseShellExecute = false;
regasmProcessStartInfo.CreateNoWindow = true;
System.Diagnostics.Process process = System.Diagnostics.Process.Start(regasmProcessStartInfo);
while (!process.HasExited)
{
string txt = process.StandardOutput.ReadToEnd();
}
using (RegistryKey config = VSRegistry.RegistryRoot(__VsLocalRegistryType.RegType_Configuration))
{
RegisterDebugEngine(location, config);
}
}
public async Task ApplyColorSchemeAsync(
ColorSchemeName schemeName, ImmutableArray <RegistryItem> registryItems, CancellationToken cancellationToken)
{
await _threadingContext.JoinableTaskFactory.SwitchToMainThreadAsync(cancellationToken);
using var registryRoot = VSRegistry.RegistryRoot(_serviceProvider, __VsLocalRegistryType.RegType_Configuration, writable: true);
foreach (var item in registryItems)
{
using var itemKey = registryRoot.CreateSubKey(item.SectionName);
itemKey.SetValue(RegistryItem.ValueName, item.ValueData);
// Flush RegistryKeys out of paranoia
itemKey.Flush();
}
registryRoot.Flush();
SetAppliedColorScheme(schemeName);
// Broadcast that system color settings have changed to force the ColorThemeService to reload colors.
NativeMethods.PostMessage(NativeMethods.HWND_BROADCAST, NativeMethods.WM_SYSCOLORCHANGE, wparam: IntPtr.Zero, lparam: IntPtr.Zero);
}
static GCManager()
{
// Allow disabling SustainedLowLatency by setting the reg key value to 0
System.Threading.Tasks.Task.Run(() =>
{
using (var root = VSRegistry.RegistryRoot(__VsLocalRegistryType.RegType_UserSettings))
{
if (root != null)
{
using var key = root.OpenSubKey("Performance");
const string name = "SustainedLowLatencyDuration";
if (key != null && key.GetValue(name) != null && key.GetValueKind(name) == Microsoft.Win32.RegistryValueKind.DWord)
{
s_delayMilliseconds = (int)key.GetValue(name, s_delayMilliseconds);
return;
}
}
}
s_delayMilliseconds = DefaultDelayMilliseconds;
});
}
private void InitializeDefaultInterpreterWatcher(IServiceProvider serviceProvider)
{
RegistryKey userSettingsKey;
if (serviceProvider != null)
{
userSettingsKey = VSRegistry.RegistryRoot(serviceProvider, __VsLocalRegistryType.RegType_UserSettings, false);
}
else
{
userSettingsKey = VSRegistry.RegistryRoot(__VsLocalRegistryType.RegType_UserSettings, false);
}
using (userSettingsKey) {
RegistryHive hive;
RegistryView view;
string keyName;
if (RegistryWatcher.GetRegistryKeyLocation(userSettingsKey, out hive, out view, out keyName))
{
if (RegistryWatcher.Instance.TryAdd(
hive, view, keyName + "\\" + DefaultInterpreterOptionsCollection,
DefaultInterpreterRegistry_Changed,
recursive: false, notifyValueChange: true, notifyKeyChange: false
) == null)
{
// DefaultInterpreterOptions subkey does not exist yet, so
// create it and then start the watcher.
SaveDefaultInterpreter();
RegistryWatcher.Instance.Add(
hive, view, keyName + "\\" + DefaultInterpreterOptionsCollection,
DefaultInterpreterRegistry_Changed,
recursive: false, notifyValueChange: true, notifyKeyChange: false
);
}
}
}
}
/// <summary>
/// Get the localized names of the scopes who's key bindings we find interesting. This is
/// a fairly unpretty way of doing this. Yet it's the only known way to achieve this in
/// Dev10.
/// </summary>
private HashSet <string> CreateImportantScopeSet()
{
try
{
using (var rootKey = VSRegistry.RegistryRoot(__VsLocalRegistryType.RegType_Configuration, writable: false))
{
using (var keyBindingsKey = rootKey.OpenSubKey("KeyBindingTables"))
{
var set = new HashSet <string>(StringComparer.OrdinalIgnoreCase);
// For "Global". The id in the registry here is incorrect for Dev10
// so hard code the known value
set.Add(GetKeyBindingScopeName(
keyBindingsKey,
"{5efc7975-14bc-11cf-9b2b-00aa00573819}",
13018,
"Global"));
// For "Text Editor"
set.Add(GetKeyBindingScopeName(
keyBindingsKey,
"{8B382828-6202-11D1-8870-0000F87579D2}",
null,
"Text Editor"));
// No scope is considered interesting as well
set.Add("");
return(set);
}
}
}
catch (Exception)
{
return(CreateDefaultImportantScopeSet());
}
}