/// <devdoc> /// This is the only method that should be calling IVsUiShell.CreateToolWindow() /// </devdoc> private ToolWindowPane CreateToolWindow(Type toolWindowType, int id, ProvideToolWindowAttribute tool) { if (toolWindowType == null) throw new ArgumentNullException("toolWindowType"); if (id < 0) throw new ArgumentOutOfRangeException(string.Format(Resources.Culture, Resources.Package_InvalidInstanceID, id)); if (!toolWindowType.IsSubclassOf(typeof(ToolWindowPane))) throw new ArgumentException(Resources.Package_InvalidToolWindowClass); if (tool == null) throw new ArgumentNullException("tool"); // First create an instance of the ToolWindowPane ToolWindowPane window = (ToolWindowPane)Activator.CreateInstance(toolWindowType); // Check if this window has a ToolBar bool hasToolBar = (window.ToolBar != null); uint flags = (uint)__VSCREATETOOLWIN.CTW_fInitNew; if (!tool.Transient) flags |= (uint)__VSCREATETOOLWIN.CTW_fForceCreate; if (hasToolBar) flags |= (uint)__VSCREATETOOLWIN.CTW_fToolbarHost; if (tool.MultiInstances) flags |= (uint)__VSCREATETOOLWIN.CTW_fMultiInstance; Guid emptyGuid = Guid.Empty; Guid toolClsid = window.ToolClsid; IVsWindowPane windowPane = null; if (toolClsid.CompareTo(Guid.Empty) == 0) { // If a tool CLSID is not specified, then host the IVsWindowPane windowPane = window.GetIVsWindowPane() as IVsWindowPane; } Guid persistenceGuid = toolWindowType.GUID; IVsWindowFrame windowFrame; // Use IVsUIShell to create frame. IVsUIShell vsUiShell = (IVsUIShell)GetService(typeof(SVsUIShell)); if (vsUiShell == null) throw new Exception(string.Format(Resources.Culture, Resources.General_MissingService, typeof(SVsUIShell).FullName)); int hr = vsUiShell.CreateToolWindow(flags, // flags (uint)id, // instance ID windowPane, // IVsWindowPane to host in the toolwindow (null if toolClsid is specified) ref toolClsid, // toolClsid to host in the toolwindow (Guid.Empty if windowPane is not null) ref persistenceGuid, // persistence Guid ref emptyGuid, // auto activate Guid null, // service provider window.Caption, // Window title null, out windowFrame); NativeMethods.ThrowOnFailure(hr); window.Package = this; // If the toolwindow is a component, site it. IComponent component = null; if (window.Window is IComponent) component = (IComponent)window.Window; else if (windowPane is IComponent) component = (IComponent)windowPane; if (component != null) { if (_componentToolWindows == null) _componentToolWindows = new PackageContainer(this); _componentToolWindows.Add((IComponent)component); } // This generates the OnToolWindowCreated event on the ToolWindowPane window.Frame = windowFrame; if (hasToolBar && windowFrame != null) { // Set the toolbar IVsToolWindowToolbarHost toolBarHost; object obj; NativeMethods.ThrowOnFailure(windowFrame.GetProperty((int)__VSFPROPID.VSFPROPID_ToolbarHost, out obj)); toolBarHost = (IVsToolWindowToolbarHost)obj; if (toolBarHost != null) { Guid toolBarCommandSet = window.ToolBar.Guid; NativeMethods.ThrowOnFailure(toolBarHost.AddToolbar((VSTWT_LOCATION)window.ToolBarLocation, ref toolBarCommandSet, (uint)window.ToolBar.ID)); } } window.OnToolBarAdded(); // If the ToolWindow was created successfully, keep track of it if (window != null) { if (_toolWindows == null) _toolWindows = new ToolWindowCollection(); _toolWindows.Add(toolWindowType.GUID, id, window); } return window; }
protected virtual void Dispose(bool disposing) { if (disposing) { // Unregister any registered editor factories. // if (_editorFactories != null) { Hashtable editorFactories = _editorFactories; _editorFactories = null; try { IVsRegisterEditors registerEditors = GetService(typeof(SVsRegisterEditors)) as IVsRegisterEditors; foreach (DictionaryEntry de in editorFactories) { try { if (registerEditors != null) { // Don't check for the return value because, even if this unregister fails, // we have anyway to try to unregister the others. registerEditors.UnregisterEditor((uint)de.Value); } } catch (Exception) { /* do nothing */ } finally { IDisposable disposable = de.Key as IDisposable; if (disposable != null) { disposable.Dispose(); } } } } catch (Exception e) { Debug.Fail(String.Format("Failed to dispose editor factories for package {0}\n{1}", this.GetType().FullName, e.Message)); } } // Unregister any registered project factories. // if (_projectFactories != null) { Hashtable projectFactories = _projectFactories; _projectFactories = null; try { IVsRegisterProjectTypes registerProjects = GetService(typeof(SVsRegisterProjectTypes)) as IVsRegisterProjectTypes; foreach (DictionaryEntry de in projectFactories) { try { if (registerProjects != null) { // As above, don't check for the return value. registerProjects.UnregisterProjectType((uint)de.Value); } } finally { IDisposable disposable = de.Key as IDisposable; if (disposable != null) { disposable.Dispose(); } } } } catch (Exception e) { Debug.Fail(String.Format("Failed to dispose project factories for package {0}\n{1}", this.GetType().FullName, e.Message)); } } // Dispose all IComponent ToolWindows // if (_componentToolWindows != null) { Container componentToolWindows = _componentToolWindows; _componentToolWindows = null; try { componentToolWindows.Dispose(); } catch (Exception e) { Debug.Fail(String.Format("Failed to dispose component toolwindows for package {0}\n{1}", this.GetType().FullName, e.Message)); } } // Dispose all pages. // if (_pagesAndProfiles != null) { Container pagesAndProfiles = _pagesAndProfiles; _pagesAndProfiles = null; try { pagesAndProfiles.Dispose(); } catch (Exception e) { Debug.Fail(String.Format("Failed to dispose component toolwindows for package {0}\n{1}", this.GetType().FullName, e.Message)); } } // Enumerate the service list and destroy all services. This should // always be done last. // if (_services != null) { try { IProfferService ps = (IProfferService)GetService(typeof(SProfferService)); Hashtable services = _services; _services = null; foreach (object value in services.Values) { object service = value; ProfferedService proffer = service as ProfferedService; try { if (null != proffer) { service = proffer.Instance; if (proffer.Cookie != 0 && ps != null) { int hr = ps.RevokeService(proffer.Cookie); if (NativeMethods.Failed(hr)) { Debug.Fail(String.Format(CultureInfo.CurrentUICulture, "Failed to unregister service {0}", service.GetType().FullName)); Trace.WriteLine(String.Format(CultureInfo.CurrentUICulture, "Failed to unregister service {0}", service.GetType().FullName)); } } } } finally { if (service is IDisposable) { ((IDisposable)service).Dispose(); } } } } catch (Exception e) { Debug.Fail(String.Format("Failed to dispose proffered service for package {0}\n{1}", this.GetType().FullName, e.Message)); } } // Disallow any service requests after this. // if (_provider != null) { // If the service provider for the current package is the service provider that we use globally // do not dispose yet. Once all packages deriving from Package are disposed we will dispose it. if (_provider != _globalProvider) { try { _provider.Dispose(); } catch (Exception e) { Debug.Fail(String.Format("Failed to dispose the global service provider for package {0}\n{1}", this.GetType().FullName, e.Message)); } } _provider = null; } if (_toolWindows != null) { _toolWindows.Dispose(); _toolWindows = null; } if (_optionKeys != null) { _optionKeys = null; } // Disconnect user preference change events // SystemEvents.UserPreferenceChanged -= new UserPreferenceChangedEventHandler(OnUserPreferenceChanged); } }