public void Unadvise() { Shell.ThreadHelper.ThrowIfNotOnUIThread(); IVsRunningDocumentTable rdt = (IVsRunningDocumentTable)Package.GetGlobalService(typeof(SVsRunningDocumentTable)); rdt.UnadviseRunningDocTableEvents(_cookie); }
internal void Unregister() { // Unregister this object from IVsUpdateSolutionEvents events if (m_updateSolutionEventsCookie != VSCOOKIE_NIL) { IVsSolutionBuildManager2 buildManager = Package.GetService <SVsSolutionBuildManager, IVsSolutionBuildManager2>(); if (buildManager != null) { buildManager.UnadviseUpdateSolutionEvents(m_updateSolutionEventsCookie); m_updateSolutionEventsCookie = VSCOOKIE_NIL; } } // Unregister this object from IVsSolutionEvents events if (m_solutionEventsCookie != VSCOOKIE_NIL) { IVsSolution solution = Package.GetService <SVsSolution, IVsSolution>(); if (solution != null) { solution.UnadviseSolutionEvents(m_solutionEventsCookie); m_solutionEventsCookie = VSCOOKIE_NIL; } } // Unregister this object from IVsRunningDocTableEvents events if (m_runningDocTableEventsCookie != VSCOOKIE_NIL) { IVsRunningDocumentTable runningDocTable = Package.GetService <SVsRunningDocumentTable, IVsRunningDocumentTable>(); if (runningDocTable != null) { runningDocTable.UnadviseRunningDocTableEvents(m_runningDocTableEventsCookie); m_runningDocTableEventsCookie = VSCOOKIE_NIL; } } }
void Hook(bool enable) { if (enable == _hooked) { return; } IVsRunningDocumentTable rdt = RunningDocumentTable; if (rdt == null) { return; } if (enable) { if (VSErr.Succeeded(rdt.AdviseRunningDocTableEvents(this, out _cookie))) { _hooked = true; } } else { _docMap.Clear(); _cookieMap.Clear(); _hooked = false; rdt.UnadviseRunningDocTableEvents(_cookie); } }
protected override void Dispose(bool disposing) { IVsSolution solution = (IVsSolution)GetService(typeof(SVsSolution)); try { solution.UnadviseSolutionEvents(solutionEventCookie); } // ReSharper disable EmptyGeneralCatchClause catch {} // ReSharper restore EmptyGeneralCatchClause base.Dispose(disposing); // Remove text manager event notifications. if (tmConnectionPoint != null) { tmConnectionPoint.Unadvise(tmConnectionCookie); tmConnectionPoint = null; } // Remove running document table (RDT) event notifications. // Ignore any errors that might occur since we're shutting down. IVsRunningDocumentTable rdt = (IVsRunningDocumentTable)GetService(typeof(SVsRunningDocumentTable)); if (rdt != null) { try { rdt.UnadviseRunningDocTableEvents(rdtEventCookie); } catch (Exception) {} } }
protected override void Dispose(bool disposing) { // Remove solution event notifications. IVsSolution solution = (IVsSolution)GetService(typeof(SVsSolution)); try { solution.UnadviseSolutionEvents(solutionEventCookie); } catch { } // Remove text manager event notifications. if (tmConnectionPoint != null) { tmConnectionPoint.Unadvise(tmConnectionCookie); tmConnectionPoint = null; } // Remove running document table (RDT) event notifications. // Ignore any errors that might occur since we're shutting down. IVsRunningDocumentTable rdt = (IVsRunningDocumentTable)GetService(typeof(SVsRunningDocumentTable)); try { rdt.UnadviseRunningDocTableEvents(rdtEventCookie); } catch (Exception) { } // Forward call to the base class. base.Dispose(disposing); }
public void Dispose() { if (documentService != null && cookie != 0) { documentService.UnadviseRunningDocTableEvents(cookie); } }
private void UnadviseRunningDocumentTableEvents() { if (runningDocumentTable != null) { ErrorHandler.ThrowOnFailure(runningDocumentTable.UnadviseRunningDocTableEvents(runningDocumentTableCookie)); runningDocumentTable = null; } }
public void Shutdown() { if (m_RDT != null) { m_RDT.UnadviseRunningDocTableEvents(m_rdtCookie); m_RDT = null; } }
/// <summary> /// Unregister RunningDocumentTable events. /// </summary> public void UnregisterRunningDocumentTableEvents() { if (DocumentTable != null) { int hr = DocumentTable.UnadviseRunningDocTableEvents(DocumentTableItemId); ErrorHandler.Succeeded(hr); } }
protected override void Dispose(bool disposing) { IVsRunningDocumentTable rdt = (IVsRunningDocumentTable)ServiceProvider.GetGlobalServiceAsync(typeof(SVsRunningDocumentTable)); rdt.UnadviseRunningDocTableEvents(rdtCookie); base.Dispose(disposing); }
void IDisposable.Dispose() { if (runningDocumentTableCookie != 0) { runningDocumentTable.UnadviseRunningDocTableEvents(runningDocumentTableCookie); runningDocumentTableCookie = 0; } }
/// <summary> /// Unsubscribe from the running document table events /// </summary> private void UnsubscribeFromEvents() { if (DocumentTable != null) { int result = DocumentTable.UnadviseRunningDocTableEvents(DocumentTableItemId); ErrorHandler.Succeeded(result); } }
private void DisposeRunningDocTableEvents() { if (rdt != null && rdtEventsCookie != 0) { rdt.UnadviseRunningDocTableEvents(rdtEventsCookie); rdtEventsCookie = 0; } rdt = null; }
void IDisposable.Dispose() { if (_runningDocumentTableCookie == 0) { return; } _runningDocumentTable.UnadviseRunningDocTableEvents(_runningDocumentTableCookie); _runningDocumentTableCookie = 0; }
public void Dispose() { if (rdt != null) { rdt.UnadviseRunningDocTableEvents(cookie); rdt = null; GC.SuppressFinalize(this); } }
private void OnWorkspaceInitialized(object sender, PythonWorkspaceContextEventArgs e) { var workspace = e.Workspace; _infoBarCheckTriggered = false; _packageInstallInfoBar = new PackageInstallWorkspaceInfoBar(_serviceProvider, workspace); _condaEnvCreateInfoBar = new CondaEnvCreateWorkspaceInfoBar(_serviceProvider, workspace); _virtualEnvCreateInfoBar = new VirtualEnvCreateWorkspaceInfoBar(_serviceProvider, workspace); _testFrameworkInfoBar = new TestFrameworkWorkspaceInfoBar(_serviceProvider, workspace); _pythonVersionNotSupportedInfoBar = new PythonNotSupportedInfoBar(_serviceProvider, InfoBarContexts.Workspace, () => workspace.CurrentFactory); workspace.AddActionOnClose(_packageInstallInfoBar, (obj => ((PythonInfoBar)obj).Dispose())); workspace.AddActionOnClose(_condaEnvCreateInfoBar, (obj => ((PythonInfoBar)obj).Dispose())); workspace.AddActionOnClose(_virtualEnvCreateInfoBar, (obj => ((PythonInfoBar)obj).Dispose())); workspace.AddActionOnClose(_testFrameworkInfoBar, (obj => ((PythonInfoBar)obj).Dispose())); workspace.AddActionOnClose( _pythonVersionNotSupportedInfoBar, obj => { ((PythonInfoBar)obj).Dispose(); workspace.ActiveInterpreterChanged -= TriggerPythonNotSupportedInforBar; } ); workspace.AddActionOnClose( _untrustedWorkspaceInfoBar, obj => { ((PythonInfoBar)obj).Dispose(); workspace.IsTrustedQueried -= TriggerUntrustedWorkspaceInfoBar; } ); workspace.ActiveInterpreterChanged += TriggerPythonNotSupportedInforBar; // When we see a Python file opened in the workspace, we trigger info bar checks. // Python files may have already been opened by the time this runs, so we'll check // the already loaded files first. If there are no Python file that trigger info bar // checks, then we'll register to be notified when files are opened. if (ErrorHandler.Succeeded(_docTable.GetRunningDocumentsEnum(out var pEnumRdt))) { if (ErrorHandler.Succeeded(pEnumRdt.Reset())) { uint[] cookie = new uint[1]; while (VSConstants.S_OK == pEnumRdt.Next(1, cookie, out _)) { var docFilePath = GetDocumentFilePath(cookie[0]); if (IsWorkspacePythonFile(docFilePath)) { TriggerInfoBar(); break; } } } } if (!_infoBarCheckTriggered) { if (ErrorHandler.Succeeded(_docTable.AdviseRunningDocTableEvents(this, out uint eventCookie))) { workspace.AddActionOnClose(_docTable, obj => _docTable.UnadviseRunningDocTableEvents(eventCookie)); } } }
void IDisposable.Dispose() { if (runningDocumentTableCookie != 0) { #pragma warning disable VSTHRD010 // Invoke single-threaded types on Main thread runningDocumentTable.UnadviseRunningDocTableEvents(runningDocumentTableCookie); #pragma warning restore VSTHRD010 // Invoke single-threaded types on Main thread runningDocumentTableCookie = 0; } }
public void Dispose() { if (0 == runningDocTableCookie || this.rdt == null) { return; } // Do not throw in case of error. rdt.UnadviseRunningDocTableEvents(runningDocTableCookie); runningDocTableCookie = 0; }
protected override void Dispose(bool disposing) { // Release the RDT cookie. IVsRunningDocumentTable rdt = (IVsRunningDocumentTable) Microsoft.VisualStudio.Shell.Package.GetGlobalService(typeof(SVsRunningDocumentTable)); rdt.UnadviseRunningDocTableEvents(rdtCookie); base.Dispose(disposing); }
void IDisposable.Dispose() { if ((int)_runningDocumentTableCookie == 0) { return; } ThreadHelper.JoinableTaskFactory.Run(async delegate { await ThreadHelper.JoinableTaskFactory.SwitchToMainThreadAsync(); _runningDocumentTable.UnadviseRunningDocTableEvents(_runningDocumentTableCookie); _runningDocumentTableCookie = 0U; }); }
public async Task DisposeAsync() { await this.JoinableTaskFactory.SwitchToMainThreadAsync(this.DisposalToken); IVsRunningDocumentTable rdt = (IVsRunningDocumentTable)(await GetServiceAsync(typeof(SVsRunningDocumentTable))); rdt.UnadviseRunningDocTableEvents(_rdtCookie); if (_outputPane != null) { _outputPane?.Hide(); IVsOutputWindow output = (IVsOutputWindow)GetService(typeof(SVsOutputWindow)); output.DeletePane(ref _paneGuid); } }
public void Shutdown() { table.UnadviseRunningDocTableEvents(m_rdtCookie); foreach (var activeView in new HashSet <IVsTextView>(_cookieList.Keys)) { try { DeactivateCursorLogger(activeView); } catch (Exception ex) { Trace.WriteLine(ex.Message); } } }
private void UnregisterRDTEvents() { if (0 == _runningDocTableCookie) { return; } IVsRunningDocumentTable rdt = GetPackageService(typeof(SVsRunningDocumentTable)) as IVsRunningDocumentTable; if (null != rdt) { // Do not throw in case of error. rdt.UnadviseRunningDocTableEvents(_runningDocTableCookie); } _runningDocTableCookie = 0; }
public void StopListening() { if (_cookie != VSConstants.VSCOOKIE_NIL && _projectDocTracker != null) { int hr = _projectDocTracker.UnadviseTrackProjectDocumentsEvents(_cookie); ErrorHandler.Succeeded(hr); // do nothing if this fails _cookie = VSConstants.VSCOOKIE_NIL; } if (_documentTable != null) { int hr = _documentTable.UnadviseRunningDocTableEvents(_documentTableItemId); ErrorHandler.Succeeded(hr); } }
protected override void Dispose(bool disposing) { ThreadHelper.ThrowIfNotOnUIThread(); if (disposed) { return; } disposed = true; if (rdt != null) { rdt.UnadviseRunningDocTableEvents(cookie); rdt = null; } }
/// <summary> /// Appelée lors du déchargement de la stratégie /// </summary> /// <param name="sender"></param> /// <param name="eventArgs"></param> public override void OnUnloading(object sender, EventArgs eventArgs) { base.OnUnloading(sender, eventArgs); IVsRunningDocumentTable rdtEvents = GetService <IVsRunningDocumentTable>(typeof(SVsRunningDocumentTable)); if (rdtEvents != null && _rdtEventsCookie != 0) { try { rdtEvents.UnadviseRunningDocTableEvents(_rdtEventsCookie); } catch { } _configFolders.Clear(); } }
void IDisposable.Dispose() { ThreadHelper.ThrowIfNotOnUIThread(); try { if (Directory.Exists(s_baseTempPath)) { Directory.Delete(s_baseTempPath, recursive: true); } } catch { } if (_runningDocumentTableCookie != 0) { _runningDocumentTable?.UnadviseRunningDocTableEvents(_runningDocumentTableCookie); _runningDocumentTableCookie = 0; } }
public void Shutdown() { table.UnadviseRunningDocTableEvents(m_rdtCookie); foreach (var activeView in new HashSet <IVsTextView>(_cookieList.Keys)) { try { DeactivateCursorLogger(activeView); } catch (Exception ex) { Trace.WriteLine(ex.Message); } } m_findEvents.FindDone -= new EnvDTE._dispFindEvents_FindDoneEventHandler(m_findEvents_FindDone); m_findEvents = null; if (m_findWindow1 != null) { var item = m_findWindow1.VisualElement as Control; if (item != null) { item.MouseDoubleClick -= viz_MouseDoubleClickFind1; } m_findWindow1 = null; } if (m_findWindow2 != null) { var item = m_findWindow2.VisualElement as Control; if (item != null) { item.MouseDoubleClick -= viz_MouseDoubleClickFind2; } m_findWindow2 = null; } }
public void Dispose() { if (!_disposed) { // shared cleanup logic if (_rdt != null) { _rdt.UnadviseRunningDocTableEvents(_rdtEventsCookie); _rdt = null; _rdtEventsCookie = 0; } if (_sel != null) { _sel.UnadviseSelectionEvents(_selEventsCookie); _selEventsCookie = 0; _sel = null; } _package.FileNameChanged -= OnAfterFileNameChanged; _disposed = true; } }
async Task DoInitializeAsync() { CloseableTabItem tabItemTabProc = GetTabItem(); var strxaml = $@"<Grid xmlns=""http://schemas.microsoft.com/winfx/2006/xaml/presentation"" xmlns:x=""http://schemas.microsoft.com/winfx/2006/xaml"" xmlns:l=""clr-namespace:{this.GetType().Namespace};assembly={ System.IO.Path.GetFileNameWithoutExtension(Assembly.GetExecutingAssembly().Location)}"" > <Grid.RowDefinitions> <RowDefinition Height=""auto""/> <RowDefinition Height=""*""/> </Grid.RowDefinitions> <StackPanel Grid.Row=""0"" HorizontalAlignment=""Left"" Height=""75"" VerticalAlignment=""Top"" Orientation=""Horizontal""> <CheckBox Margin=""15,0,0,10"" Content=""Output To Debug OutputPane"" IsChecked=""{{Binding UseOutputPane}}"" ToolTip=""Output to Debug OutputPane 'PerfGraphVSIX'""/> <TextBox xml:space=""preserve"" > IVsMonitorSelection until this tab is closed. Output to Debug OutputPane or LogStatus </TextBox> </StackPanel> <Grid Name=""gridUser"" Grid.Row = ""1""></Grid> </Grid> "; var strReader = new System.IO.StringReader(strxaml); var xamlreader = XmlReader.Create(strReader); var grid = (Grid)(XamlReader.Load(xamlreader)); tabItemTabProc.Content = grid; grid.DataContext = this; var gridUser = (Grid)grid.FindName("gridUser"); _OutputPane = await GetOutputPaneAsync(); _OutputPane.Clear(); uint cookieSelectionEvents = 0; uint cookieRdt = 0; await ThreadHelper.JoinableTaskFactory.RunAsync(async() => { LogMessage("Here in MySimpleSample " + DateTime.Now.ToString("MM/dd/yy hh:mm:ss")); await TaskScheduler.Default; // switch to background thread LogMessage("Logger message from MySimpleSample"); var SolutionService = await _asyncServiceProvider.GetServiceAsync(typeof(SVsSolution)) as IVsSolution; LogMessage($"{nameof(SolutionService)} {SolutionService}"); var oleMenuCommandService = await _asyncServiceProvider.GetServiceAsync(typeof(IMenuCommandService)) as OleMenuCommandService; LogMessage($"{nameof(oleMenuCommandService)} = {oleMenuCommandService}"); var VsShellMonitorSelection = await _asyncServiceProvider.GetServiceAsync(typeof(SVsShellMonitorSelection)) as IVsMonitorSelection; LogMessage($"{nameof(VsShellMonitorSelection)} = {VsShellMonitorSelection}"); VsShellMonitorSelection.AdviseSelectionEvents(this, out cookieSelectionEvents); IVsRunningDocumentTable vsRunningDocumentTable = await _asyncServiceProvider.GetServiceAsync(typeof(IVsRunningDocumentTable)) as IVsRunningDocumentTable; //vsRunningDocumentTable.AdviseRunningDocTableEvents(this, out cookieRdt); void UnSubscribe() { VsShellMonitorSelection.UnadviseSelectionEvents(cookieSelectionEvents); vsRunningDocumentTable.UnadviseRunningDocTableEvents(cookieRdt); } tabItemTabProc.TabItemClosed += async(o, e) => { UnSubscribe(); await ThreadHelper.JoinableTaskFactory.SwitchToMainThreadAsync(); _perfGraphToolWindowControl.TabControl.SelectedIndex = 0; }; }); }