/// <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);
}
}
