protected override void Initialize() { base.Initialize(); VSUtils.ForegroundThreadGuard.BindThread(); var componentModel = (IComponentModel)GetService(typeof(SComponentModel)); classificationColorManager = componentModel.DefaultExportProvider.GetExportedValue<ClassificationColorManager>(); shellService = GetService(typeof(SVsShell)) as IVsShell; if (shellService != null) ErrorHandler.ThrowOnFailure(shellService.AdviseBroadcastMessages(this, out broadcastEventCookie)); IServiceContainer serviceContainer = this; serviceContainer.AddService(typeof(GeneralOptionsPage), delegate { return GetDialogPage(typeof(GeneralOptionsPage)); }, promote:true); serviceContainer.AddService(typeof(FantomasOptionsPage), delegate { return GetDialogPage(typeof(FantomasOptionsPage)); }, promote:true); OleMenuCommandService mcs = GetService(typeof(IMenuCommandService)) as OleMenuCommandService; var shell = GetService(typeof(SVsUIShell)) as IVsUIShell; var logger = new Logger(ServiceProvider.GlobalProvider); if (mcs != null) { var newFolderMenu = new FolderMenuCommands(DTE.Value, mcs, shell); newFolderMenu.SetupCommands(); } }
private void AdviseBroadcastMessages() { shellService = serviceProvider.GetService(typeof(SVsShell)) as IVsShell; if (shellService != null) ErrorHandler.ThrowOnFailure(shellService.AdviseBroadcastMessages(this, out broadcastEventCookie)); }
public void Dispose() { if (this.solution != null && this.solutionEventsCookie != 0) { GC.SuppressFinalize(this); this.solution.UnadviseSolutionEvents(this.solutionEventsCookie); this.AfterSolutionLoaded = null; this.BeforeSolutionClosed = null; this.AfterSolutionClosed = null; this.solutionEventsCookie = 0; this.solution = null; } if (this.shell != null) { if (this.shellPropertyEventsCookie != 0) { this.shell.UnadviseShellPropertyChanges(this.shellPropertyEventsCookie); this.shellPropertyEventsCookie = 0; } if (this.broadcastMessageEventsCookie != 0) { this.shell.UnadviseBroadcastMessages(this.broadcastMessageEventsCookie); this.broadcastMessageEventsCookie = 0; } this.shell = null; } }
private static bool TryGetKeyBindingScopeName(IVsShell vsShell, RegistryKey keyBindingsKey, string subKeyName, uint? id, out string localizedScopeName) { try { using (var subKey = keyBindingsKey.OpenSubKey(subKeyName, writable: false)) { uint resourceId; if (id.HasValue) { resourceId = id.Value; } else { resourceId = UInt32.Parse((string)subKey.GetValue(null)); } var package = Guid.Parse((string)subKey.GetValue("Package")); ErrorHandler.ThrowOnFailure(vsShell.LoadPackageString(ref package, resourceId, out localizedScopeName)); return !string.IsNullOrEmpty(localizedScopeName); } } catch (Exception) { localizedScopeName = null; return false; } }
/// <summary> /// Initializes a new instance of the <see cref="ShellEventListener"/> class. /// </summary> /// <param name="package">The package hosting the event listener.</param> /// <param name="shellService">The shell service.</param> internal ShellEventListener(EditorConfigPackage package, IVsShell shellService) : base(package) { _shellService = shellService; if (_shellService == null) return; _shellService.AdviseBroadcastMessages(this, out _broadcastEventCookie); _shellService.AdviseShellPropertyChanges(this, out _propertyEventCookie); }
public void Initialize() { shellService = provider.GetService(typeof(SVsShell)) as IVsShell; if (shellService != null) { ErrorHandler.ThrowOnFailure(shellService.AdviseBroadcastMessages(this, out cookie)); } }
internal DteInitializer(IVsShell shellService, Action callback) { this.shellService = shellService; this.callback = callback; // Set an event handler to detect when the IDE is fully initialized int hr = this.shellService.AdviseShellPropertyChanges(this, out cookie); ErrorHandler.ThrowOnFailure(hr); }
internal KeyBindingService(SVsServiceProvider serviceProvider, IOptionsDialogService service, [EditorUtilsImport] IProtectedOperations protectedOperations, IVimApplicationSettings vimApplicationSettings) { _dte = serviceProvider.GetService<SDTE, _DTE>(); _vsShell = serviceProvider.GetService<SVsShell, IVsShell>(); _optionsDialogService = service; _protectedOperations = protectedOperations; _vimApplicationSettings = vimApplicationSettings; _importantScopeSet = new Lazy<HashSet<string>>(CreateImportantScopeSet); }
public ShellEvents([Import(typeof(SVsServiceProvider))] IServiceProvider serviceProvider) { Guard.NotNull(() => serviceProvider, serviceProvider); this.shellService = serviceProvider.GetService<SVsShell, IVsShell>(); Microsoft.VisualStudio.ErrorHandler.ThrowOnFailure( this.shellService.AdviseShellPropertyChanges(this, out this.shellCookie)); }
public OptionsManager(IServiceProvider serviceProvider, IVsShell vsShell, IEnumerable<Lazy<IOptionsPage>> optionPages) { this.serviceProvider = serviceProvider; this.vsShell = vsShell; this.optionPages = optionPages; // This is the same as shellPackage.ApplicationRegistryRoot this.registryRoot = VSRegistry.RegistryRoot(serviceProvider, __VsLocalRegistryType.RegType_Configuration, false).Name; }
public VisualStudioThemeEngine(IServiceProvider serviceProvider) { dte = (DTE2)serviceProvider.GetService(typeof(SDTE)); // Register to Visual Studio theme change shellService = serviceProvider.GetService(typeof(SVsShell)) as IVsShell; if (shellService != null) ErrorHandler.ThrowOnFailure(shellService.AdviseBroadcastMessages(this, out broadcastCookie)); }
public ReSharperIntegrationBootstrap(IVsShell vsShell, IVsOleServiceProvider vsOleServiceProvider) { this.vsShell = vsShell; this.vsOleServiceProvider = vsOleServiceProvider; int fInstalled; IsReSharperInstalled = vsShell.IsPackageInstalled(GuidList.ReSharperPkg, out fInstalled) == 0 && Convert.ToBoolean(fInstalled); }
internal KeyBindingService(SVsServiceProvider serviceProvider, IOptionsDialogService service, IProtectedOperations protectedOperations, ILegacySettings legacySettings) { _dte = serviceProvider.GetService<SDTE, _DTE>(); _vsShell = serviceProvider.GetService<SVsShell, IVsShell>(); _optionsDialogService = service; _protectedOperations = protectedOperations; _legacySettings = legacySettings; _importantScopeSet = new Lazy<HashSet<string>>(CreateImportantScopeSet); }
internal ScopeData(IVsShell vsShell) { if (!TryGetMainScopeNames(vsShell, out _globalScopeName, out _textEditorScopeName)) { _globalScopeName = DefaultGlobalScopeName; _textEditorScopeName = DefaultTextEditorScopeName; } _importantScopeSet = CreateImportantScopeSet(_globalScopeName, _textEditorScopeName); }
private static IVsPackage TryLoadPackage(IVsShell vsShell, Guid packageGuid) { IVsPackage package; if (vsShell.IsPackageLoaded(ref packageGuid, out package) == VSConstants.S_OK && package != null) return package; if (vsShell.LoadPackage(ref packageGuid, out package) == VSConstants.S_OK) return package; return null; }
/// <summary> /// Initializes a new instance of the <see cref="ShellEventListener"/> class. /// </summary> /// <param name="package">The package hosting the event listener.</param> /// <param name="shellService">The shell service.</param> internal ShellEventListener(VSTalkPackage package, IVsShell shellService) : base(package) { _shellService = shellService; if (_shellService != null) { _shellService.AdviseBroadcastMessages(this, out _broadcastEventCookie); _shellService.AdviseShellPropertyChanges(this, out _propertyEventCookie); } }
internal FallbackKeyProcessorProvider(SVsServiceProvider serviceProvider, IKeyUtil keyUtil, IVimApplicationSettings vimApplicationSettings, IVim vim) { _dte = (_DTE)serviceProvider.GetService(typeof(_DTE)); _keyUtil = keyUtil; _vimApplicationSettings = vimApplicationSettings; _vim = vim; _vsShell = (IVsShell)serviceProvider.GetService(typeof(SVsShell)); _scopeData = new ScopeData(_vsShell); }
internal ExternalEditorManager(SVsServiceProvider serviceProvider, IVsAdapter vsAdapter) { _vsAdapter = vsAdapter; _vsShell = serviceProvider.GetService<SVsShell, IVsShell>(); _adapterList.Add(new SnippetExternalEditAdapter()); _isResharperInstalled = CheckResharperInstalled(); if (_isResharperInstalled) { _adapterList.Add(new ResharperExternalEditAdapter()); } }
public static MarkdownPackage ForceLoadPackage(IVsShell shell) { Guid packageGuid = new Guid(GuidList.guidMarkdownPackagePkgString); IVsPackage package; if (VSConstants.S_OK == shell.IsPackageLoaded(ref packageGuid, out package)) return package as MarkdownPackage; else if (ErrorHandler.Succeeded(shell.LoadPackage(ref packageGuid, out package))) return package as MarkdownPackage; return null; }
internal ScopeData(IVsShell vsShell) { if (!TryGetMainScopeNames(vsShell, out _globalScopeName, out _textEditorScopeName, out _solutionExplorerScopeName)) { _globalScopeName = DefaultGlobalScopeName; _textEditorScopeName = DefaultTextEditorScopeName; _solutionExplorerScopeName = DefaultSolutionExplorerScopeName; } _scopeKindMap = BuildScopeKindMap(); }
/// <summary> /// Initializes 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 async void Initialize() { base.Initialize(); shellService = GetService(typeof(SVsShell)) as IVsShell; if (shellService != null) { ErrorHandler.ThrowOnFailure(shellService.AdviseShellPropertyChanges(this, out shellPropertyCookie)); } else { await Task.Delay(TimeSpan.FromSeconds(5)); FullInitialize(); } }
/// <summary> /// Initializes a new instance of the <see cref="PackageSettings"/> class. /// </summary> /// <param name="serviceProvider">The <see cref="ServiceProvider"/> to use.</param> /// <param name="machineSettingsRegistryKey"> /// Relative registry path to machine-level settings. The path is relative to the Visual Studio registry root. /// </param> protected PackageSettings(ServiceProvider serviceProvider, string machineSettingsRegistryKey) { Tracer.VerifyNonNullArgument(serviceProvider, "serviceProvider"); // Read in the Visual Studio registry root. IVsShell vsShell = serviceProvider.GetVsShell(classType, Tracer.ConstructorMethodName); object rootPathObj; int hr = vsShell.GetProperty((int)__VSSPROPID.VSSPROPID_VirtualRegistryRoot, out rootPathObj); this.visualStudioRegistryRoot = (string)rootPathObj; this.machineRootPath = this.RegistryPathCombine(this.visualStudioRegistryRoot, machineSettingsRegistryKey); // Initialize all of the machine settings. this.traceLevel = new MachineSettingEnum(this.MachineRootPath, KeyNames.TraceLevel, Tracer.Level.Critical, typeof(Tracer.Level)); }
public void PackageLoadTest() { UIThreadInvoker.Invoke((ThreadInvoker) delegate() { //Get the Shell Service IVsShell shellService = VsIdeTestHostContext.ServiceProvider.GetService(typeof(SVsShell)) as IVsShell; Assert.IsNotNull(shellService); //Validate package load IVsPackage package; Guid packageGuid = new Guid("C4128D99-2000-41D1-A6C3-704E6C1A3DE2"); Assert.IsTrue(0 == shellService.LoadPackage(ref packageGuid, out package)); Assert.IsNotNull(package, "Package failed to load"); }); }
public static MarkdownPackage ForceLoadPackage(IVsShell shell) { Guid packageGuid = new Guid(GuidList.guidMarkdownPackagePkgString); IVsPackage package; if (VSConstants.S_OK == shell.IsPackageLoaded(ref packageGuid, out package)) { return(package as MarkdownPackage); } else if (ErrorHandler.Succeeded(shell.LoadPackage(ref packageGuid, out package))) { return(package as MarkdownPackage); } return(null); }
internal ExternalEditorManager( SVsServiceProvider serviceProvider, IVsAdapter vsAdapter, IViewTagAggregatorFactoryService viewTagAggregatorFactoryService) { _vsAdapter = vsAdapter; _viewTagAggregatorFactoryService = viewTagAggregatorFactoryService; _vsShell = serviceProvider.GetService <SVsShell, IVsShell>(); _adapterList.Add(new SnippetExternalEditAdapter()); _isResharperInstalled = CheckResharperInstalled(); if (_isResharperInstalled) { _adapterList.Add(new ResharperExternalEditAdapter()); } }
/// <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() { QueryFirstCmd.Initialize(this); base.Initialize(); // sby : set an eventlistener for shell property changes IVsShell shellService = GetService(typeof(SVsShell)) as IVsShell; if (shellService != null) { ErrorHandler.ThrowOnFailure(shellService.AdviseShellPropertyChanges(this, out cookie)); } // do it anyway zombieProofInitialization(); }
private static void Initialize() { DTE2 dte = ServiceProvider.GetService(typeof(SDTE)) as DTE2; _onDteInitialized?.Invoke(dte); if (dte != null) { return; } IVsShell shellService = ServiceProvider.GetService(typeof(SVsShell)) as IVsShell; new DteInitializer(shellService, Initialize); }
public void PackageLoadTest() { UIThreadInvoker.Invoke((ThreadInvoker) delegate() { //Get the Shell Service IVsShell shellService = VsIdeTestHostContext.ServiceProvider.GetService(typeof(SVsShell)) as IVsShell; Assert.IsNotNull(shellService); //Validate package load IVsPackage package; Guid packageGuid = new Guid(MufflonoSoft.CodingDojoHelperVsExtension.GuidList.guidCodingDojoHelperVsExtensionPkgString); Assert.IsTrue(0 == shellService.LoadPackage(ref packageGuid, out package)); Assert.IsNotNull(package, "Package failed to load"); }); }
public void PackageLoadTest() { UIThreadInvoker.Invoke((ThreadInvoker) delegate() { //Get the Shell Service IVsShell shellService = VsIdeTestHostContext.ServiceProvider.GetService(typeof(SVsShell)) as IVsShell; Assert.IsNotNull(shellService); //Validate package load IVsPackage package; Guid packageGuid = new Guid(mskold.TfsAdminTools.GuidList.guidTfsAdminToolsPkgString); Assert.IsTrue(0 == shellService.LoadPackage(ref packageGuid, out package)); Assert.IsNotNull(package, "Package failed to load"); }); }
/// <include file='doc\WindowPane.uex' path='docs/doc[@for="WindowPane.IVsWindowPane.CreatePaneWindow"]/*' /> /// <internalonly/> /// <devdoc> /// IVsWindowPane implementation. /// </devdoc> int IVsWindowPane.CreatePaneWindow(IntPtr hwndParent, int x, int y, int cx, int cy, out IntPtr pane) { OnCreate(); IntPtr hwnd = Window.Handle; int style = (int)UnsafeNativeMethods.GetWindowLong(hwnd, NativeMethods.GWL_STYLE); // set up the required styles of an IVsWindowPane style |= (NativeMethods.WS_CLIPSIBLINGS | NativeMethods.WS_CHILD | NativeMethods.WS_VISIBLE); style &= ~(NativeMethods.WS_POPUP | NativeMethods.WS_MINIMIZE | NativeMethods.WS_MAXIMIZE | NativeMethods.WS_DLGFRAME | NativeMethods.WS_SYSMENU | NativeMethods.WS_THICKFRAME | NativeMethods.WS_MINIMIZEBOX | NativeMethods.WS_MAXIMIZEBOX); UnsafeNativeMethods.SetWindowLong(hwnd, NativeMethods.GWL_STYLE, (IntPtr)style); style = (int)UnsafeNativeMethods.GetWindowLong(hwnd, NativeMethods.GWL_EXSTYLE); style &= ~(NativeMethods.WS_EX_DLGMODALFRAME | NativeMethods.WS_EX_NOPARENTNOTIFY | NativeMethods.WS_EX_TOPMOST | NativeMethods.WS_EX_MDICHILD | NativeMethods.WS_EX_TOOLWINDOW | NativeMethods.WS_EX_CONTEXTHELP | NativeMethods.WS_EX_APPWINDOW); UnsafeNativeMethods.SetWindowLong(hwnd, NativeMethods.GWL_EXSTYLE, (IntPtr)style); UnsafeNativeMethods.SetParent(hwnd, (IntPtr)hwndParent); UnsafeNativeMethods.SetWindowPos(hwnd, IntPtr.Zero, x, y, cx, cy, NativeMethods.SWP_NOZORDER | NativeMethods.SWP_NOACTIVATE); UnsafeNativeMethods.ShowWindow(hwnd, NativeMethods.SW_SHOWNORMAL); // Sync broadcast events so we update our UI when colors/fonts change. // if (_vsShell == null) { _vsShell = (IVsShell)GetService(typeof(SVsShell)); if (_vsShell != null) { NativeMethods.ThrowOnFailure(_vsShell.AdviseBroadcastMessages(this, out _broadcastEventCookie)); } } pane = hwnd; return(NativeMethods.S_OK); }
public string GetInstallDirectory(IServiceProvider serviceProvider) { string str = (string)null; IVsShell service = (IVsShell)serviceProvider.GetService(typeof(SVsShell)); if (service != null) { object pvar = (object)null; service.GetProperty(-9007, out pvar); if (pvar != null) { str = pvar as string; } } return(str); }
/// <summary> /// Force load package. /// A hack method which is called from analyzers to ensure that the package is loaded before diagnostics are executed. /// </summary> /// <returns/> public static async System.Threading.Tasks.Task ForceLoadPackageAsync() { await ThreadHelper.JoinableTaskFactory.SwitchToMainThreadAsync(); IVsShell shell = await VS.GetServiceAsync <SVsShell, IVsShell>(); if (shell == null) { return; } var packageToBeLoadedGuid = new Guid(PackageGuidString); shell.LoadPackage(ref packageToBeLoadedGuid, out var _); await System.Threading.Tasks.TaskScheduler.Default; }
public static Version TryGetReSharperVersion(this IVsShell vsShell) { if (vsShell == null || !IsPackageInstalled(vsShell, _reSharperPackageGuid)) { return(null); } IVsPackage vsPackage = TryLoadPackage(vsShell, _reSharperPackageGuid); if (vsPackage == null) { return(null); } return(vsPackage.GetType().Assembly.GetName().Version); }
/// <summary> /// In general a key processor applies to a specific IWpfTextView but /// by not making use of it, the fallback processor can be reused for /// multiple text views /// </summary> internal FallbackKeyProcessor(IVsShell vsShell, _DTE dte, IKeyUtil keyUtil, IVimApplicationSettings vimApplicationSettings, ITextView textView, IVimBuffer vimBuffer, ScopeData scopeData) { _vsShell = vsShell; _dte = dte; _keyUtil = keyUtil; _vimApplicationSettings = vimApplicationSettings; _vimBuffer = vimBuffer; _scopeData = scopeData; _fallbackCommandList = Enumerable.Empty<FallbackCommand>().ToLookup(x => 'a'); // Register for key binding changes and get the current bindings _vimApplicationSettings.SettingsChanged += OnSettingsChanged; GetKeyBindings(); textView.Closed += OnTextViewClosed; }
private static void Initialize() { if (vsShell != null) { return; } vsShell = VsServiceProvider.GetService <IVsShell>(); object objProp; int res = vsShell.GetProperty((int)__VSSPROPID2.VSSPROPID_InstallRootDir, out objProp); if (res == VSConstants.S_OK && objProp is string) { _InstallRootDir = objProp as string; } }
/// <summary> /// In general a key processor applies to a specific IWpfTextView but /// by not making use of it, the fallback processor can be reused for /// multiple text views /// </summary> internal FallbackKeyProcessor(IVsShell vsShell, _DTE dte, IKeyUtil keyUtil, IVimApplicationSettings vimApplicationSettings, ITextView textView, IVimBuffer vimBuffer, ScopeData scopeData) { _vsShell = vsShell; _dte = dte; _keyUtil = keyUtil; _vimApplicationSettings = vimApplicationSettings; _vimBuffer = vimBuffer; _scopeData = scopeData; _fallbackCommandList = new List <FallbackCommand>(); // Register for key binding changes and get the current bindings _vimApplicationSettings.SettingsChanged += OnSettingsChanged; GetKeyBindings(); textView.Closed += OnTextViewClosed; }
/// <include file='doc\VsRegistry.uex' path='docs/doc[@for="VsRegistry.GetOptionRoot"]/*' /> /// <devdoc> /// Retrieves the shell's root key for VS options, or uses the value of /// GetDefaultBase if we coundn't get the shell service. /// </devdoc> private static string GetOptionRoot(IServiceProvider serviceProvider) { string optionRoot; IVsShell vsh = (IVsShell)serviceProvider.GetService(typeof(IVsShell)); if (vsh == null) { optionRoot = GetDefaultBase(); } else { optionRoot = vsh.GetProperty(__VSSPROPID.VSSPROPID_VirtualRegistryRoot).ToString(); } return(optionRoot); }
private static IVsPackage TryLoadPackage(IVsShell vsShell, Guid packageGuid) { IVsPackage package; if (vsShell.IsPackageLoaded(ref packageGuid, out package) == VSConstants.S_OK && package != null) { return(package); } if (vsShell.LoadPackage(ref packageGuid, out package) == VSConstants.S_OK) { return(package); } return(null); }
/// <summary> /// Get the localized strings that represent various keyboard keys. Copied from keynameinfo.cpp in env\msenv\core /// </summary> private void PopulateKeyMaps() { Guid shellPkg = CLSID_VsEnvironmentPackage; IVsShell shell = Shell; foreach (KeyValuePair <Key, uint> kvp in KeyResourceIdMap) { string keyName; if (ErrorHandler.Succeeded(shell.LoadPackageString(ref shellPkg, kvp.Value, out keyName))) { this.keyNameKeyIdMap[keyName] = kvp.Key; this.keyIdKeyNameMap[kvp.Key] = keyName; } } }
private void CheckVsStarted() { _vsShell = (IVsShell)VsPackage.GetGlobalService(typeof(SVsShell)); _vsShell.GetProperty((int)__VSSPROPID4.VSSPROPID_ShellInitialized, out var value); if (value is bool) { if ((bool)value) { _application.FireStarted(); } else { _vsShell.AdviseShellPropertyChanges(this, out _vsShellEventsCookie); } } }
/// <summary> /// Initializes a new instance of the <see cref="CommandManager"/> class. /// </summary> public CommandManager( IServiceProvider serviceProvider, IEnumerable<Lazy<ICommandExtension, CommandAttribute>> allCommands, IEnumerable<Lazy<ICommandFilter, CommandFilterAttribute>> allFilters, IEnumerable<Lazy<ICommandInterceptor, CommandInterceptorAttribute>> allInterceptors) { this.serviceProvider = serviceProvider; this.vsShell = serviceProvider.GetService<SVsShell, IVsShell>(); this.commandEvents = serviceProvider.GetService<DTE>().Events.CommandEvents; this.commands = allCommands; this.filters = allFilters; this.interceptors = allInterceptors.ToList(); this.commandEvents.BeforeExecute += OnBeforeExecute; this.commandEvents.AfterExecute += OnAfterExecute; }
public ShellEvents(IServiceProvider serviceProvider) { Guard.NotNull(() => serviceProvider, serviceProvider); this.services = serviceProvider; this.shellService = serviceProvider.GetService<SVsShell, IVsShell>(); object isZombie; ErrorHandler.ThrowOnFailure(this.shellService.GetProperty((int)__VSSPROPID.VSSPROPID_Zombie, out isZombie)); this.IsInitialized = !((bool)isZombie); // TODO: see if we still should advise changes if IsInitialized is true at this point? ErrorHandler.ThrowOnFailure( this.shellService.AdviseShellPropertyChanges(this, out this.shellCookie)); }
/// <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 static void Initialize() { ThreadHelper.ThrowIfNotOnUIThread(); if (vsShell != null) { return; } vsShell = VsServiceProvider.GetService <IVsShell>(); int res = vsShell.GetProperty((int)__VSSPROPID2.VSSPROPID_InstallRootDir, out object o); if (res == VSConstants.S_OK && o is string property) { _InstallRootDir = property; } }
public SolutionSettings(IAnkhServiceProvider context) : base(context) { ThreadHelper.ThrowIfNotOnUIThread(); IVsShell shell = GetService <IVsShell>(typeof(SVsShell)); if (shell == null) { throw new InvalidOperationException("IVsShell not available"); } object r; if (VSErr.Succeeded(shell.GetProperty((int)__VSSPROPID.VSSPROPID_VirtualRegistryRoot, out r))) { _vsUserRoot = (string)r; } else { _vsUserRoot = @"SOFTWARE\Microsoft\VisualStudio\8.0"; } string baseName = _vsUserRoot; if (_vsUserRoot.EndsWith(@"\UserSettings", StringComparison.OrdinalIgnoreCase)) { _inRanu = true; baseName = _vsUserRoot.Substring(0, _vsUserRoot.Length - 13); _vsAppRoot = baseName + @"\Configuration"; } else { _vsAppRoot = _vsUserRoot; } if (baseName.StartsWith(@"SOFTWARE\", StringComparison.OrdinalIgnoreCase)) { baseName = baseName.Substring(9); // Should always trigger } if (baseName.StartsWith(@"Microsoft\", StringComparison.OrdinalIgnoreCase)) { baseName = baseName.Substring(10); // Give non-ms hives a prefix } _hiveSuffix = baseName; }
public SolutionEventsListener(IServiceProvider serviceProvider) { this.InitNullEvents(); this.solution = serviceProvider.GetService(typeof(SVsSolution)) as IVsSolution; if (this.solution != null) { this.solution.AdviseSolutionEvents(this, out this.solutionEventsCookie); } this.shell = (IVsShell)serviceProvider.GetService(typeof(SVsShell)); if (this.shell != null) { this.shell.AdviseShellPropertyChanges(this, out this.shellPropertyEventsCookie); this.shell.AdviseBroadcastMessages(this, out this.broadcastMessageEventsCookie); } }
/// <summary> /// Retrieves the fxcop dierctory location /// </summary> private static string GetFxCopDirectoryLocation() { IVsShell shell = Microsoft.VisualStudio.Shell.Package.GetGlobalService(typeof(IVsShell)) as IVsShell; Debug.Assert(shell != null, "Could not retrieve the IVsShell service from the global service provider"); object virtualRegistryRootAsObject; // We do not want to throw. If we cannot set the solution related constants we set them to empty string. shell.GetProperty((int)__VSSPROPID.VSSPROPID_VirtualRegistryRoot, out virtualRegistryRootAsObject); string virtualRegistryRoot = (string)virtualRegistryRootAsObject; if (String.IsNullOrEmpty(virtualRegistryRoot)) { return(String.Empty); } // Ensure there is a trailing backslash if (virtualRegistryRoot[virtualRegistryRoot.Length - 1] != Path.DirectorySeparatorChar) { virtualRegistryRoot += Path.DirectorySeparatorChar; } virtualRegistryRoot += FxCopRegistryRelativePathEntry; using (RegistryKey root = Registry.LocalMachine.OpenSubKey(virtualRegistryRoot)) { if (null == root) { return(String.Empty); } using (RegistryKey key = root.OpenSubKey(FxCopRegistryRelativePathEntry)) { if (key != null) { string fxcopInstallDir = key.GetValue(FxCopRegistryInstallDirKeyName) as string; return((fxcopInstallDir == null) ? String.Empty : fxcopInstallDir); } } } return(String.Empty); }
protected override void Initialize() { Trace.WriteLine(string.Format(CultureInfo.CurrentCulture, "Entering Initialize() of: {0}", this.ToString())); base.Initialize(); OleMenuCommandService mcs = GetService(typeof(IMenuCommandService)) as OleMenuCommandService; _Shell = GetService(typeof(SVsShell)) as IVsShell; if (null != mcs) { SetupCommand(mcs, PkgCmdIDList.cmdidUsusNetCockpit, MenuItemCallback_Cockpit); SetupCommand(mcs, PkgCmdIDList.cmdidUsusNetHotspots, MenuItemCallback_Hotspots); SetupCommand(mcs, PkgCmdIDList.cmdidUsusNetDistributions, MenuItemCallback_Distributions); SetupCommand(mcs, PkgCmdIDList.cmdidUsusNetCleanCode, MenuItemCallback_CleanCode); SetupCommand(mcs, PkgCmdIDList.cmdidUsusNetCurrent, MenuItemCallback_Current); SetupCommand(mcs, PkgCmdIDList.cmdidUsusNetSqi, MenuItemCallback_Sqi); } }
/// <summary> /// Initializes a new instance of the <see cref="SolutionEventsListener"/> class. /// </summary> /// <param name="serviceProvider">The service provider.</param> public SolutionEventsListener(IServiceProvider serviceProvider) { this.InitNullEvents(); this.solution = serviceProvider.GetService(typeof(SVsSolution)) as IVsSolution; if (this.solution != null) { this.solution.AdviseSolutionEvents(this, out this.solutionEventsCookie); } this.shell = (IVsShell)serviceProvider.GetService(typeof(SVsShell)); if (this.shell != null) { this.shell.AdviseShellPropertyChanges(this, out this.shellPropertyEventsCookie); this.shell.AdviseBroadcastMessages(this, out this.broadcastMessageEventsCookie); } }
internal static bool IsShellInCommandLineMode(System.IServiceProvider serviceProvider) { Utilities.ArgumentNotNull("serviceProvider", serviceProvider); IVsShell shell = serviceProvider.GetService(typeof(SVsShell)) as IVsShell; if (shell == null) { throw new InvalidOperationException(); } object isInCommandLineModeAsObject; ErrorHandler.ThrowOnFailure(shell.GetProperty((int)__VSSPROPID.VSSPROPID_IsInCommandLineMode, out isInCommandLineModeAsObject)); return((bool)isInCommandLineModeAsObject); }
/// <summary> /// Gets the installation directory for the current instance of Visual Studio. /// </summary> /// <returns>Full path to the VS instalation directory</returns> public string GetVsInstallDirectory() { string installDirectory = null; IVsShell shell = this.GetService(typeof(SVsShell)) as IVsShell; if (shell != null) { object installDirectoryObj; shell.GetProperty((int)__VSSPROPID.VSSPROPID_InstallDirectory, out installDirectoryObj); if (installDirectoryObj != null) { installDirectory = installDirectoryObj as string; } } return(installDirectory); }
/// <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 async System.Threading.Tasks.Task InitializeAsync(CancellationToken cancellationToken, IProgress <ServiceProgressData> progress) { await this.JoinableTaskFactory.SwitchToMainThreadAsync(cancellationToken); QueryFirstCmd.Initialize(this); await base.InitializeAsync(cancellationToken, progress); // sby : set an eventlistener for shell property changes IVsShell shellService = await GetServiceAsync(typeof(SVsShell)) as IVsShell; if (shellService != null) { ErrorHandler.ThrowOnFailure(shellService.AdviseShellPropertyChanges(this, out cookie)); } // do it anyway zombieProofInitialization(); }
public static bool TryGetPropertyValue( this IVsShell shell, __VSSPROPID id, out IntPtr value ) { var hresult = shell.GetProperty((int)id, out var objValue); if (ErrorHandler.Succeeded(hresult) && objValue != null) { value = (IntPtr.Size == 4) ? (IntPtr)(int)objValue : (IntPtr)(long)objValue; return(true); } value = default; return(false); }
/// <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() { base.Initialize(); FGetCommand.Initialize(this); VListWindowCommand.Initialize(this); IVsShell shell_service = GetService(typeof(SVsShell)) as IVsShell; bool test = true; dte2 = (EnvDTE80.DTE2)Microsoft.VisualStudio.Shell.Package.GetGlobalService(typeof(Microsoft.VisualStudio.Shell.Interop.SDTE)); _m3dfw_namespace = null; _getFctPtrList_function = null; test = false; }
public ShellEvents(IServiceProvider serviceProvider) { Guard.NotNull(() => serviceProvider, serviceProvider); this.services = serviceProvider; this.shellService = serviceProvider.GetService <SVsShell, IVsShell>(); object isZombie; ErrorHandler.ThrowOnFailure(this.shellService.GetProperty((int)__VSSPROPID.VSSPROPID_Zombie, out isZombie)); this.IsInitialized = !((bool)isZombie); // TODO: see if we still should advise changes if IsInitialized is true at this point? ErrorHandler.ThrowOnFailure( this.shellService.AdviseShellPropertyChanges(this, out this.shellCookie)); }
private static void LoadEDMPackage(IVsShell vsShell) { Debug.Assert(vsShell != null, "unexpected null value for vsShell"); IVsPackage package = null; if (vsShell != null) { var packageGuid = PackageConstants.guidEscherPkg; var hr = vsShell.IsPackageLoaded(ref packageGuid, out package); if (NativeMethods.Failed(hr) || package == null) { hr = vsShell.LoadPackage(ref packageGuid, out package); if (NativeMethods.Failed(hr)) { var msg = String.Format(CultureInfo.CurrentCulture, Resources.PackageLoadFailureExceptionMessage, hr); throw new InvalidOperationException(msg); } } } }
public void Dispose() { if (cookie != 0 && shellService != null) { try { shellService.UnadviseBroadcastMessages(cookie); } catch (Exception) { // Possibly VS is shutting down so ignore the exception. } finally { cookie = 0; shellService = null; } } GC.SuppressFinalize(this); }
/// <include file='doc\WindowPane.uex' path='docs/doc[@for="WindowPane.Dispose1"]' /> /// <devdoc> /// Called when this window pane is being disposed. /// </devdoc> protected virtual void Dispose(bool disposing) { if (disposing) { if (_vsShell != null) { try { // Don't check for return code because here we can't do anything in case of failure. _vsShell.UnadviseBroadcastMessages(_broadcastEventCookie); } catch (COMException) { /* do nothing */ } _vsShell = null; _broadcastEventCookie = 0; } IWin32Window window = Window; if (window is IDisposable) { try { ((IDisposable)window).Dispose(); } catch (Exception) { Debug.Fail("Failed to dispose window"); } } window = null; if (_commandService != null && _commandService is IDisposable) { try { ((IDisposable)_commandService).Dispose(); } catch (Exception) { Debug.Fail("Failed to dispose command service"); } } _commandService = null; if (_parentProvider != null) _parentProvider = null; if (_helpService != null) _helpService = null; // Do not clear _provider. SetSite will do it for us. _zombie = true; } }
internal KeyBindingService(SVsServiceProvider serviceProvider, IOptionsDialogService service) { _dte = serviceProvider.GetService<SDTE, _DTE>(); _vsShell = serviceProvider.GetService<SVsShell, IVsShell>(); _optionsDialogService = service; }