public void Associate(MetaFeature metaFeature, ITypedServiceProvider serviceProvider)
{
if (m_metaCommand != null || m_serviceProvider != null)
{
throw new InvalidOperationException("Associate should only be called once on a IFeature instance.");
}
if (metaFeature == null)
{
throw new ArgumentNullException("metaFeature");
}
if (serviceProvider == null)
{
throw new ArgumentNullException("serviceProvider");
}
m_metaCommand = metaFeature as MetaCommand;
m_serviceProvider = serviceProvider;
IMenuCommandService menuService = m_serviceProvider.GetService <IMenuCommandService>();
Debug.Assert(menuService != null);
if (menuService != null)
{
menuService.AddCommand(this);
}
}
public static ITaskInteraction Create(
MSBuildFramework.IBuildEngine buildEngine,
ITaskOutputHandler outputHandler,
ITask task,
IArgumentProvider arguments,
ITypedServiceProvider services)
{
return new BuildTaskInteraction(task, arguments, outputHandler, buildEngine, services);
}
public static ITaskInteraction Create(
MSBuildFramework.IBuildEngine buildEngine,
ITaskOutputHandler outputHandler,
ITask task,
IArgumentProvider arguments,
ITypedServiceProvider services)
{
return(new BuildTaskInteraction(task, arguments, outputHandler, buildEngine, services));
}
protected virtual void Dispose(bool disposing)
{
// This could happen: when user disconnects add-in
// Debug.Assert(disposing, "Finalizing " + this.GetType().Name + " without disposing.");
m_serviceProvider = null;
m_metaFeature = null;
Debug.WriteLine("Disposed feature of type: " + m_metaFeature);
}
/// <summary>
/// Called on a feature object right after it has been created from the
/// meta-feature information.
/// </summary>
/// <param name="metaFeature">Corresponding MetaFeature which created the feature.</param>
/// <param name="serviceProvider">Feature context (service provider).</param>
public void Associate(MetaFeature metaFeature, ITypedServiceProvider serviceProvider)
{
Debug.Assert(!m_disposed);
if (metaFeature == null)
{
throw new ArgumentNullException("metaFeature");
}
if (serviceProvider == null)
{
throw new ArgumentNullException("serviceProvider");
}
m_metaFeature = metaFeature;
m_serviceProvider = serviceProvider;
VsShell.IVsUIShell vsUIShell = m_serviceProvider.GetService <VsShell.IVsUIShell>();
Debug.Assert(vsUIShell != null);
if (vsUIShell != null)
{
Guid toolWindowID = this.GetType().GUID;
int[] position = new int[1];
VsShell.IVsWindowFrame frame;
Guid emptyGuid = Guid.Empty;
int hr = vsUIShell.CreateToolWindow(
(int)VsShell.__VSCREATETOOLWIN.CTW_fInitNew,
0,
this,
ref emptyGuid,
ref toolWindowID,
ref emptyGuid,
null,
m_metaFeature.Name,
position,
out frame);
// If the add-in is reloaded, the CreateToolWindow method may fail because
// previous tool window may not be destroyed correctly. We try to create
// tool window again.
if (ErrorHandler.Failed(hr))
{
ErrorHandler.ThrowOnFailure(vsUIShell.CreateToolWindow(
(int)VsShell.__VSCREATETOOLWIN.CTW_fInitNew,
0,
this,
ref emptyGuid,
ref toolWindowID,
ref emptyGuid,
null,
m_metaFeature.Name,
position,
out frame));
}
}
}
private BuildTaskInteraction(
ITask task,
IArgumentProvider arguments,
ITaskOutputHandler outputHandler,
MSBuildFramework.IBuildEngine buildEngine,
ITypedServiceProvider services)
: base (arguments, services)
{
this.outputHandler = outputHandler;
this.loggers = new Lazy<BuildTaskLoggers>(() => new BuildTaskLoggers(buildEngine, task, arguments));
}
private BuildTaskInteraction(
ITask task,
IArgumentProvider arguments,
ITaskOutputHandler outputHandler,
MSBuildFramework.IBuildEngine buildEngine,
ITypedServiceProvider services)
: base(arguments, services)
{
this.outputHandler = outputHandler;
this.loggers = new Lazy <BuildTaskLoggers>(() => new BuildTaskLoggers(buildEngine, task, arguments));
}
/// <summary>
/// Does the actual work of instantiating feature object before Associate is called
/// from CreateFeature (if required).
/// </summary>
/// <param name="serviceProvider">Context the feature is being created in.</param>
/// <returns>Created feature object.</returns>
protected override IDisposable DoCreateFeature(ITypedServiceProvider serviceProvider)
{
if (this.IsCustomCommand)
{
// Custom command requires CommandID to be passed in.
return(Activator.CreateInstance(this.FeatureType, this.CustomCommandId) as IDisposable);
}
else
{
// Predefined commands have default constructors.
return(Activator.CreateInstance(this.FeatureType) as IDisposable);
}
}
public override void Associate(MetaFeature metaFeature, ITypedServiceProvider serviceProvider)
{
base.Associate(metaFeature, serviceProvider);
m_monitorDocumentsService = serviceProvider.GetService <IMonitorDocumentsService>();
Debug.Assert(m_monitorDocumentsService != null);
if (m_monitorDocumentsService != null)
{
m_monitorDocumentsService.ForAllOpenedDocuments(delegate(DocumentEventArgs args)
{
OnDocumentOpened(m_monitorDocumentsService, args);
});
m_monitorDocumentsService.DocumentOpened += OnDocumentOpened;
m_monitorDocumentsService.DocumentClosed += OnDocumentClosed;
}
}
/// <summary>
/// Creates feature of this meta-feature type in specified context.
/// </summary>
/// <param name="serviceProvider">The context in which the new feature is created.</param>
/// <returns>Created feature.</returns>
/// <remarks>
/// Note that even though feature might choose to implement IFeature interface, this is not
/// a requirement (whereas IDisposable is a requirement).
/// </remarks>
public IDisposable CreateFeature(ITypedServiceProvider serviceProvider)
{
IDisposable disposableFeature = this.DoCreateFeature(serviceProvider);
Debug.Assert(disposableFeature != null);
IFeature feature = disposableFeature as IFeature;
if (feature != null)
{
feature.Associate(this, serviceProvider);
}
Debug.WriteLine("Created feature " + this + ".");
return(disposableFeature);
}
/// <summary>
/// Called on a feature object right after it has been created from the
/// meta-feature information.
/// </summary>
/// <param name="metaFeature">Corresponding MetaFeature which created the feature.</param>
/// <param name="serviceProvider">Feature context (service provider).</param>
public override void Associate(MetaFeature metaFeature, ITypedServiceProvider serviceProvider)
{
base.Associate(metaFeature, serviceProvider);
IList <MetaFeature> children = metaFeature.Store.GetRolePlayers(metaFeature, MetaRelationshipKind.Child);
Debug.Assert(children != null);
if (children != null)
{
foreach (MetaFeature childMetaFeature in children)
{
if (childMetaFeature.Enabled)
{
this.CreateFeature(childMetaFeature.FeatureType);
}
}
}
}
/// <summary>
/// Called on a feature object right after it has been created from the
/// meta-feature information.
/// </summary>
/// <param name="metaFeature">Corresponding MetaFeature which created the feature.</param>
/// <param name="serviceProvider">Feature context (service provider).</param>
public virtual void Associate(MetaFeature metaFeature, ITypedServiceProvider serviceProvider)
{
if (m_metaFeature != null || m_serviceProvider != null)
{
throw new InvalidOperationException();
}
if (metaFeature == null)
{
throw new ArgumentNullException("metaFeature");
}
m_metaFeature = metaFeature;
// We do allow global context to have no parent context which is expected.
if (serviceProvider == null)
{
throw new ArgumentNullException("serviceProvider");
}
m_serviceProvider = serviceProvider;
}
/// <summary>
/// Does the actual work of instantiating feature object before Associate is called
/// from CreateFeature (if required).
/// </summary>
/// <param name="serviceProvider">Context the feature is being created in.</param>
/// <returns>Created feature object.</returns>
protected virtual IDisposable DoCreateFeature(ITypedServiceProvider serviceProvider)
{
if (serviceProvider == null)
{
throw new ArgumentNullException("serviceProvider");
}
// It is relatively common for types to take a IServiceProvider interface as an argument,
// so we do provide a special case here for such situations (tool-windows and dialogs are
// good examples of this).
ConstructorInfo spConstructor = m_featureType.GetConstructor(new Type[] { typeof(IServiceProvider) });
if (spConstructor != null)
{
return(spConstructor.Invoke(new object[] { serviceProvider }) as IDisposable);
}
else
{
// If failed, assume the type has a defalut constructor.
return(Activator.CreateInstance(m_featureType) as IDisposable);
}
}
protected virtual void Dispose(bool disposing)
{
Debug.Assert(disposing, "Finalizing CustomCommand without disposing.");
if (disposing)
{
if (m_serviceProvider != null)
{
IMenuCommandService menuService = m_serviceProvider.GetService <IMenuCommandService>();
if (menuService != null)
{
menuService.RemoveCommand(this);
}
m_serviceProvider = null;
}
}
m_metaCommand = null;
m_selection = null;
Debug.WriteLine("Unloaded and disposed command " + m_metaCommand);
}
public override void Associate(MetaFeature metaFeature, ITypedServiceProvider serviceProvider)
{
if (metaFeature == null)
{
throw new ArgumentNullException("metaFeature");
}
if (serviceProvider == null)
{
throw new ArgumentNullException("serviceProvider");
}
base.Associate(metaFeature, serviceProvider);
Debug.Assert(m_scrollPanel == null);
if (m_scrollPanel == null)
{
DiagramContext diagramContext = serviceProvider.GetService <IFeatureContext>() as DiagramContext;
Debug.Assert(diagramContext != null && diagramContext.DiagramView != null);
if (diagramContext != null && diagramContext.DiagramView != null)
{
// Create and show a thumbnail form.
DiagramView diagramView = diagramContext.DiagramView;
m_scrollPanel = new Panel();
m_scrollPanel.BackgroundImage = new Bitmap(typeof(ThumbnailViewForm), @"ThumbnailView.bmp");
m_scrollPanel.Anchor = AnchorStyles.Bottom | AnchorStyles.Right;
m_scrollPanel.BackgroundImageLayout = ImageLayout.Center;
diagramView.Invoke(new EventHandler(delegate(object sender, EventArgs e)
{
diagramView.Controls.Add(m_scrollPanel);
}));
m_scrollPanel.Width = diagramView.Controls[1].Width;
m_scrollPanel.Height = diagramView.Controls[2].Height;
m_scrollPanel.Left = diagramView.Width - m_scrollPanel.Width;
m_scrollPanel.Top = diagramView.Height - m_scrollPanel.Height;
m_scrollPanel.Anchor = AnchorStyles.Right | AnchorStyles.Bottom;
m_scrollPanel.BringToFront();
m_scrollPanel.MouseDown += delegate(object sender, MouseEventArgs args)
{
// Right-click on the thumbnail icon brings pan/zoom tool window.
Debug.Assert(args != null);
if (args != null && args.Button == MouseButtons.Right)
{
IFeatureContext featureContext = this.ServiceProvider.GetService <IFeatureContext>();
Debug.Assert(featureContext != null);
if (featureContext != null)
{
PanZoomWindow toolWindow = featureContext.CreateFeature <PanZoomWindow>();
Debug.Assert(toolWindow != null);
if (toolWindow != null)
{
toolWindow.Show();
}
}
}
else
{
// Any other click on thumbnail icon displays the thumbnail form.
new ThumbnailViewForm(m_scrollPanel, diagramView.DiagramClientView).ShowDialog();
}
};
}
}
}
/// <summary>
/// Execution handler for tasks running under MSBuild.
/// </summary>
/// <param name="services">Override services, can be null. Used to get services before falling back on defaults.</param>
public BuildTaskExecution(MSBuildFramework.IBuildEngine buildEngine, ITaskOutputHandler outputHandler, IArgumentProvider argumentProvider, ITaskRegistry taskRegistry, ITypedServiceProvider services = null)
: base(argumentProvider, taskRegistry, services)
{
this.outputHandler = outputHandler;
this.buildEngine = buildEngine;
}
/// <summary>
/// Execution handler for tasks running under the console.
/// </summary>
/// <param name="services">Override services, can be null. Used to get services before falling back on defaults.</param>
public ConsoleTaskExecution(IArgumentProvider argumentProvider, ITaskRegistry taskRegistry, ITypedServiceProvider services = null)
: base(argumentProvider, taskRegistry, services)
{
}
protected TaskExecution(IArgumentProvider argumentProvider, ITaskRegistry taskRegistry, ITypedServiceProvider services)
{
ArgumentProvider = argumentProvider;
_taskRegistry = taskRegistry;
Services = services;
}
protected TaskExecution(IArgumentProvider argumentProvider, ITaskRegistry taskRegistry, ITypedServiceProvider services)
{
this.ArgumentProvider = argumentProvider;
this.taskRegistry = taskRegistry;
this.Services = services;
}
protected TaskInteraction(IArgumentProvider arguments, ITypedServiceProvider services)
{
this.Arguments = arguments;
this.services = services;
}
/// <summary>
/// Execution handler for tasks running under MSBuild.
/// </summary>
/// <param name="services">Override services, can be null. Used to get services before falling back on defaults.</param>
public BuildTaskExecution(MSBuildFramework.IBuildEngine buildEngine, ITaskOutputHandler outputHandler, IArgumentProvider argumentProvider, ITaskRegistry taskRegistry, ITypedServiceProvider services = null)
: base(argumentProvider, taskRegistry, services)
{
_outputHandler = outputHandler;
_buildEngine = buildEngine;
}
private ConsoleTaskInteraction(ITask task, IArgumentProvider arguments, ITypedServiceProvider services)
: base(arguments, services)
{
_loggers = new Lazy <ConsoleTaskLoggers>(() => new ConsoleTaskLoggers(task, arguments));
}
/// <summary>
/// Execution handler for tasks running under the console.
/// </summary>
/// <param name="services">Override services, can be null. Used to get services before falling back on defaults.</param>
public ConsoleTaskExecution(IArgumentProvider argumentProvider, ITaskRegistry taskRegistry, ITypedServiceProvider services = null)
: base(argumentProvider, taskRegistry, services)
{
}
public static ITaskInteraction Create(ITask task, IArgumentProvider arguments, ITypedServiceProvider services)
{
return(new ConsoleTaskInteraction(task, arguments, services));
}
public static ITaskInteraction Create(ITask task, IArgumentProvider arguments, ITypedServiceProvider services)
{
return new ConsoleTaskInteraction(task, arguments, services);
}
private ConsoleTaskInteraction(ITask task, IArgumentProvider arguments, ITypedServiceProvider services)
: base(arguments, services)
{
this.loggers = new Lazy<ConsoleTaskLoggers>(() => new ConsoleTaskLoggers(task, arguments));
}
