/// <summary>
/// Implements the OnDisconnection method of the IDTExtensibility2 interface.
/// Occurs when he Add-in is loaded into Visual Studio.
/// </summary>
/// <param name="application">A reference to an instance of the IDE, DTE.</param>
/// <param name="connectMode">
/// An <see cref="ext_ConnectMode"/> enumeration value that indicates
/// the way the add-in was loaded into Visual Studio.
/// </param>
/// <param name="instance">An <see cref="AddIn"/> reference to the add-in's own instance.</param>
/// <param name="custom">An empty array that you can use to pass host-specific data for use in the add-in.</param>
public void OnConnection(object application, ext_ConnectMode connectMode, object instance, ref Array custom)
{
App = (DTE2)application;
Instance = (AddIn)instance;
Events = App.Events as Events2;
Logger = new OutputWindowLogger(App);
Logger.Log("Loading...");
Compose(); // Do not attempt to use [Import]s before this line!
if (Chirp == null)
{
Logger.Log("Unable to load.");
return;
}
BindEvents();
PrintLoadedEngines();
Logger.Log("Ready");
if (App.Solution.IsOpen)
{
SolutionOpened();
foreach (var project in App.Solution.Projects.Cast <Project>())
{
ProjectAdded(project);
}
}
}
public async System.Threading.Tasks.Task HandleChangeAsync(IWpfTextView textView)
{
await ThreadHelper.JoinableTaskFactory.SwitchToMainThreadAsync();
try
{
var profiler = MiniProfiler.StartNew(nameof(HandleChangeAsync));
profiler.Storage = new NLogStorage(LogManager.GetLogger("profiler"));
using (profiler.Step("HandleChangeCode"))
{
SnapshotPoint caretPosition = textView.Caret.Position.BufferPosition;
Microsoft.CodeAnalysis.Document roslynDocument = caretPosition.Snapshot.GetOpenDocumentInCurrentContextWithChanges();
if (roslynDocument == null)
{
OutputWindowLogger.WriteLn($"Unable to get c# file to process. Name {caretPosition.Snapshot.ContentType.DisplayName}");
return;
}
await GotoAsyncPackage.Storage.AnalyzeAndUpdateSingleAsync(roslynDocument);
}
}
catch (Exception ex)
{
LogManager.GetLogger("error").Error(ex, "CSharpFileContentOnChange.HandleChange");
OutputWindowLogger.WriteLn($"Exception occured during handling csharp file change: {ex.Message}");
}
}
/// <summary>
/// Implements the OnDisconnection method of the IDTExtensibility2 interface.
/// Occurs when he Add-in is loaded into Visual Studio.
/// </summary>
/// <param name="application">A reference to an instance of the IDE, DTE.</param>
/// <param name="connectMode">
/// An <see cref="ext_ConnectMode"/> enumeration value that indicates
/// the way the add-in was loaded into Visual Studio.
/// </param>
/// <param name="instance">An <see cref="AddIn"/> reference to the add-in's own instance.</param>
/// <param name="custom">An empty array that you can use to pass host-specific data for use in the add-in.</param>
public void OnConnection(object application, ext_ConnectMode connectMode, object instance, ref Array custom)
{
App = (DTE2) application;
Instance = (AddIn) instance;
Events = App.Events as Events2;
Logger = new OutputWindowLogger(App);
Logger.Log("Loading...");
Compose(); // Do not attempt to use [Import]s before this line!
if(Chirp == null)
{
Logger.Log("Unable to load.");
return;
}
BindEvents();
PrintLoadedEngines();
Logger.Log("Ready");
if(App.Solution.IsOpen)
{
SolutionOpened();
foreach (var project in App.Solution.Projects.Cast<Project>())
{
ProjectAdded(project);
}
}
}
private MapProcessingResult HandleMaps(ConfigProcessingResult configProcessingResult)
{
var xmlFiles = DocumentHelper.GetXmlFiles(_projectItems);
var configs = GotoAsyncPackage.Storage.SqlMapConfigProvider.GetAll();
if (_options.MapsOptions.IndexAllMaps)
{
return(HandleCorrectMapFiles(xmlFiles, configs));
}
if (_options.MapsOptions.IndexOnlyMapsInConfig)
{
var fileNames = configs.SelectMany(e => e.Maps).Select(e => e.Value);
var filteredXmlFiles = GetExistingInMaps(xmlFiles, fileNames);
if (fileNames.Any(e => e.IndexOfAny(Path.GetInvalidFileNameChars()) >= 0))
{
//Fallback scenario, when path/filename is invaild than just index all maps in solution,
//maps that are are not referenced in config, will be assigned to default config.
OutputWindowLogger.WriteLn("Found invaild character for file. Parsing all maps found in solution.");
return(HandleAllMapFiles(xmlFiles, configs));
}
return(HandleCorrectMapFiles(filteredXmlFiles, configs));
}
return(new MapProcessingResult());
}
private IEnumerable <SqlMapConfig> GetConfigs(IEnumerable <ProjectItem> projectItems)
{
var configs = GetConfigsFiles(projectItems);
OutputWindowLogger.WriteLn($"Found config candidates: {string.Join(" ", configs.Select(e=>e.FilePath))}");
var parsedConfigs = configs.Select(config => _xmlIndexer.ParseSingleConfigFile(config)).Where(e => e.ParsedSuccessfully);
OutputWindowLogger.WriteLn($"Parsed configs: {string.Join(" ", parsedConfigs.Select(e=>e.Name))}");
return(parsedConfigs);
}
public void ShouldWriteInOutputWindow()
{
MockOutputWindow mockVsOutputWindow = new MockOutputWindow();
OutputWindowLogger logger = new OutputWindowLogger(mockVsOutputWindow);
logger.Log("test");
Assert.IsTrue(mockVsOutputWindow.GetPaneCalled);
Assert.AreEqual(ProjectLinkerGuids.GuidProjectLinkerOutputPane, mockVsOutputWindow.GetPaneArgumentGuidPane);
StringAssert.Contains(mockVsOutputWindow.GetPaneReturnValue.OutputStringThreadSafeArgumentString, "test");
}
public void ItemRenamed(ProjectItem ProjectItem, string OldName)
{
try
{
Microsoft.VisualStudio.Shell.ThreadHelper.ThrowIfNotOnUIThread();
GotoAsyncPackage.Storage.CodeQueries.RenameStatmentsForFile(OldName, ProjectItem.Name);
GotoAsyncPackage.Storage.XmlQueries.RenameStatmentsForFile(OldName, ProjectItem.Name);
}
catch (Exception ex)
{
LogManager.GetLogger("error").Error(ex, "ProjectItemEventsEx.ItemRenamed");
OutputWindowLogger.WriteLn($"Exception occured during ProjectItemEventsEx.ItemRenamed: { ex.Message}");
}
}
public int OnAfterBackgroundSolutionLoadComplete()
{
Debug.WriteLine("OnAfterBackgroundSolutionLoadComplete()");
try
{
//Load Xml files from indexer
_actions.OnSolutionLoadComplete();
}
catch (Exception ex)
{
LogManager.GetLogger("error").Error(ex, "SolutionEventsHandler.OnAfterBackgroundSolutionLoadComplete");
OutputWindowLogger.WriteLn($"Exception occured during SolutionEventsHandler.OnAfterBackgroundSolutionLoadComplete: { ex.Message}");
}
return(VSConstants.S_OK);
}
public override void MenuItemCallback(object sender, EventArgs e)
{
try
{
_documentProcessor.TryResolveQueryValueAtCurrentSelectedLine(out ExpressionResult expressionResult, out string queryValue);
_finalActionFactory
.GetFinalRenameQueryActionsExecutor(StatusBar, _commandWindow, GotoAsyncPackage.EnvDTE, Package.Workspace)
.Execute(queryValue, expressionResult);
}
catch (Exception ex)
{
LogManager.GetLogger("error").Error(ex, "QueryRenameActions.MenuItemCallback");
OutputWindowLogger.WriteLn($"Exception occured during QueryRenameActionsMenuCallback: {ex.Message}");
}
}
public void ValidateAllSpans()
{
try
{
foreach (var validator in _validators)
{
(validator as IBufferValidator).ValidateAllSpans();
}
}
catch (Exception ex)
{
LogManager.GetLogger("error").Error(ex, "XmlValidatorsAggregator.ValidateAllSpans");
OutputWindowLogger.WriteLn($"Exception occured during XmlValidatorsAggregator.ValidateAllSpans: { ex.Message}");
}
}
public int OnQueryCloseSolution(object pUnkReserved, ref int pfCancel)
{
try
{
//Remove everything from indexer instance
_actions.SolutionOnClose();
//Remove Errors
TableDataSource.Instance.CleanAllErrors();
}
catch (Exception ex)
{
LogManager.GetLogger("error").Error(ex, "SolutionEventsHandler.OnQueryCloseSolution");
OutputWindowLogger.WriteLn($"Exception occured during SolutionEventsHandler.OnQueryCloseSolution: { ex.Message}");
}
return(1);
}
/// <summary>
/// Initializes a new instance of the <see cref="InliningAnalyzerCommands"/> class.
/// Adds our command handlers for menu (commands must exist in the command table file)
/// </summary>
private async Task InitializeAsync()
{
await ThreadHelper.JoinableTaskFactory.SwitchToMainThreadAsync();
var dte2 = (DTE2)Package.GetGlobalService(typeof(SDTE));
_serviceProvider = new ServiceProvider(dte2 as Microsoft.VisualStudio.OLE.Interop.IServiceProvider);
var container = await _package.GetServiceAsync(typeof(Microsoft.VisualStudio.ComponentModelHost.SComponentModel)) as Microsoft.VisualStudio.ComponentModelHost.IComponentModel;
container.DefaultCompositionService.SatisfyImportsOnce(this);
_outputLogger = new OutputWindowLogger(_package);
_statusBarLogger = new StatusBarLogger(_package);
OleMenuCommandService commandService = await _package.GetServiceAsync(typeof(IMenuCommandService)) as OleMenuCommandService;
if (commandService != null)
{
OleMenuCommand startMenuItem = new OleMenuCommand(StartMenuItemCallback, new CommandID(CommandSet, StartCommandId));
startMenuItem.BeforeQueryStatus += OnBeforeQueryStatusProject;
startMenuItem.Enabled = dte2.Solution.IsOpen;
commandService.AddCommand(startMenuItem);
OleMenuCommand startForAssemblyMenuItem = new OleMenuCommand(StartForAssemblyMenuItemCallback, new CommandID(CommandSet, StartForAssemblyCommandId));
startForAssemblyMenuItem.BeforeQueryStatus += OnBeforeQueryStatusEnabled;
startForAssemblyMenuItem.Enabled = dte2.Solution.IsOpen;
commandService.AddCommand(startForAssemblyMenuItem);
OleMenuCommand menuItem = new OleMenuCommand(ToggleMenuItemCallback, new CommandID(CommandSet, ToggleCommandId));
menuItem.BeforeQueryStatus += OnBeforeQueryStatusToggle;
menuItem.Enabled = dte2.Solution.IsOpen;
commandService.AddCommand(menuItem);
OleMenuCommand optionsMenuItem = new OleMenuCommand(OpenOptionsCallback, new CommandID(CommandSet, OpenOptionsCommandId));
commandService.AddCommand(optionsMenuItem);
OleMenuCommand contextMenuItem = new OleMenuCommand(StartForScopeMenuItemCallback, new CommandID(CommandSetContextMenu, StartForScopeCommandId));
contextMenuItem.BeforeQueryStatus += OnBeforeQueryStatusEnabled;
contextMenuItem.Enabled = dte2.Solution.IsOpen;
commandService.AddCommand(contextMenuItem);
}
}
public override void MenuItemCallback(object sender, EventArgs e)
{
try
{
var profiler = MiniProfiler.StartNew($"{nameof(GoToQueryActions2)}.{nameof(MenuItemCallback)}");
profiler.Storage = new NLogStorage(LogManager.GetLogger("profiler"));
using (profiler.Step("Event start"))
{
_documentProcessor.TryResolveQueryValueAtCurrentSelectedLine(out ExpressionResult expressionResult, out string queryValue);
_finalActionFactory
.GetFinalGoToQueryActionsExecutor(StatusBar, _commandWindow, MapNamespaceHelper.IsQueryWithNamespace(queryValue))
.Execute(queryValue, expressionResult);
}
}
catch (Exception ex)
{
LogManager.GetLogger("error").Error(ex, "GoToQuery.MenuItemCallback");
OutputWindowLogger.WriteLn($"Exception occured during GoToActionMenuCallback: {ex.Message}");
}
}
public async Task <List <CSharpIndexerResult> > BuildIndexerAsync(List <Document> documents)
{
var results = new List <CSharpIndexerResult>();
Stopwatch sw = new Stopwatch();
sw.Start();
foreach (var document in documents)
{
if (!Regex.IsMatch(document.FilePath, @"(\\service|\\TemporaryGeneratedFile_.*|\\assemblyinfo|\\assemblyattributes|\.(g\.i|g|designer|generated|assemblyattributes))\.(cs|vb)$"))
{
results.Add(await BuildFromDocumentAsync(document));
}
}
sw.Stop();
await ThreadHelper.JoinableTaskFactory.SwitchToMainThreadAsync();
OutputWindowLogger.WriteLn($"Building Queries db from code ended in {sw.ElapsedMilliseconds} ms. Found {results.Count} queries. In {documents.Count} documents.");
return(results);
}
public void OnBuildBegin(vsBuildScope Scope, vsBuildAction Action)
{
try
{
ThreadHelper.ThrowIfNotOnUIThread();
var projectItemHelper = new ProjectItemRetreiver(GotoAsyncPackage.EnvDTE);
var projectItems = projectItemHelper.GetProjectItemsFromSolutionProjects();
foreach (var xmlFile in DocumentHelper.GetXmlFiles(projectItems))
{
var validator = XmlValidatorsAggregator.Create.AllValidatorsForBuild(xmlFile.FilePath);
validator.ValidateBuildDocument();
validator.AddToErrorList();
}
}
catch (Exception ex)
{
LogManager.GetLogger("error").Error(ex, "BuildEvents.OnBuildBegin");
OutputWindowLogger.WriteLn($"Exception occured during BuildEvents.OnBuildBegin: { ex.Message}");
}
}
public void ItemAdded(ProjectItem ProjectItem)
{
try
{
Microsoft.VisualStudio.Shell.ThreadHelper.ThrowIfNotOnUIThread();
string projectItemExtension = Path.GetExtension(ProjectItem.Name);
if (projectItemExtension == ".xml")
{
GotoAsyncPackage.Storage.AnalyzeAndStoreSingle(new XmlFileInfo
{
FilePath = ProjectItem.FileNames[0],
ProjectName = ProjectItem.ContainingProject.Name
});
}
}
catch (Exception ex)
{
LogManager.GetLogger("error").Error(ex, "ProjectItemEventsEx.ItemAdded");
OutputWindowLogger.WriteLn($"Exception occured during ProjectItemEventsEx.ItemAdded: { ex.Message}");
}
}
#pragma warning restore CS0649
/// <summary>
/// Initializes a new instance of the <see cref="InliningAnalyzerCommands"/> class.
/// Adds our command handlers for menu (commands must exist in the command table file)
/// </summary>
/// <param name="package">Owner package, not null.</param>
private InliningAnalyzerCommands(Package package)
{
if (package == null)
{
throw new ArgumentNullException("package");
}
var dte2 = (DTE2)Package.GetGlobalService(typeof(SDTE));
var sp = new ServiceProvider(dte2 as Microsoft.VisualStudio.OLE.Interop.IServiceProvider);
var container = sp.GetService(typeof(Microsoft.VisualStudio.ComponentModelHost.SComponentModel)) as Microsoft.VisualStudio.ComponentModelHost.IComponentModel;
container.DefaultCompositionService.SatisfyImportsOnce(this);
_package = package;
_outputLogger = new OutputWindowLogger(package);
_statusBarLogger = new StatusBarLogger(package);
OleMenuCommandService commandService = this.ServiceProvider.GetService(typeof(IMenuCommandService)) as OleMenuCommandService;
if (commandService != null)
{
OleMenuCommand startMenuItem = new OleMenuCommand(StartMenuItemCallback, new CommandID(CommandSet, StartCommandId));
startMenuItem.BeforeQueryStatus += OnBeforeQueryStatusStart;
startMenuItem.Enabled = dte2.Solution.IsOpen;
commandService.AddCommand(startMenuItem);
OleMenuCommand menuItem = new OleMenuCommand(ToggleMenuItemCallback, new CommandID(CommandSet, ToggleCommandId));
menuItem.BeforeQueryStatus += OnBeforeQueryStatusToggle;
menuItem.Enabled = dte2.Solution.IsOpen;
commandService.AddCommand(menuItem);
OleMenuCommand optionsMenuItem = new OleMenuCommand(OpenOptionsCallback, new CommandID(CommandSet, OpenOptionsCommandId));
commandService.AddCommand(optionsMenuItem);
OleMenuCommand contextMenuItem = new OleMenuCommand(StartForScopeMenuItemCallback, new CommandID(CommandSetContextMenu, StartForScopeCommandId));
contextMenuItem.Enabled = dte2.Solution.IsOpen;
commandService.AddCommand(contextMenuItem);
}
}
public async System.Threading.Tasks.Task HandleChangeAsync(IWpfTextView textView)
{
try
{
await ThreadHelper.JoinableTaskFactory.SwitchToMainThreadAsync();
var profiler = MiniProfiler.StartNew(nameof(HandleChangeAsync));
profiler.Storage = new NLogStorage(LogManager.GetLogger("profiler"));
using (profiler.Step("HandleChangeXml"))
{
var snapshot = textView.Caret.Position.BufferPosition.Snapshot;
ITextDocument textDoc;
textView.TextBuffer.Properties.TryGetProperty(typeof(ITextDocument), out textDoc);
using (var stringReader = new StringReader(snapshot.GetText()))
{
var project = GotoAsyncPackage.EnvDTE.Solution.FindProjectItem(textDoc.FilePath)?.ContainingProject?.Name;
XmlParser baseParser = new XmlParser(stringReader).Load();
if (baseParser.BatisXmlFileType == BatisXmlFileTypeEnum.SqlMap)
{
BatisXmlMapParser parser = new BatisXmlMapParser(baseParser).WithFileInfo(textDoc.FilePath, project);
var newStatments = parser.GetMapFileStatments();
GotoAsyncPackage.Storage.XmlQueries.UpdateStatmentForFileWihoutKey(newStatments);
}
if (baseParser.BatisXmlFileType == BatisXmlFileTypeEnum.SqlMapConfig)
{
BatisXmlConfigParser parser = new BatisXmlConfigParser(baseParser).WithFileInfo(textDoc.FilePath, project);
GotoAsyncPackage.Storage.SqlMapConfigProvider.UpdateOrAddConfig(parser.Result);
}
}
}
}
catch (Exception ex)
{
LogManager.GetLogger("error").Error(ex, "XmlFileContentOnChange.HandleChange");
OutputWindowLogger.WriteLn($"Exception occured during handling xml file change: {ex.Message}");
}
}
public List <Statement> BuildIndexer(IDictionary <SqlMapConfig, IEnumerable <XmlFileInfo> > configFileInfosPairs)
{
var result = new List <Statement>();
Stopwatch sw = new Stopwatch();
sw.Start();
foreach (var configFilesPair in configFileInfosPairs)
{
foreach (var xmlSolutionDocument in configFilesPair.Value)
{
BatisXmlMapParser parser = new BatisXmlMapParser().WithFileInfo(xmlSolutionDocument.FilePath, xmlSolutionDocument.ProjectName).Load();
bool isBatisQueryXmlFile = parser.XmlNamespace == XmlMapConstants.XmlNamespace;
if (isBatisQueryXmlFile)
{
result.AddRange(parser.GetMapFileStatments());
}
}
}
sw.Stop();
OutputWindowLogger.WriteLn($"Building Queries db from xml ended in {sw.ElapsedMilliseconds} ms. Found {result.Count} queries.");
return(result);
}
public virtual LoggingWireup UseOutputWindow()
{
OutputWindowLogger.MakePrimaryLogger();
return(this);
}
public async System.Threading.Tasks.Task WorkspaceChangedAsync(object sender, WorkspaceChangeEventArgs e)
{
var profiler = MiniProfiler.StartNew(nameof(WorkspaceChangedAsync));
profiler.Storage = new NLogStorage(LogManager.GetLogger("profiler"));
var workspace = sender as VisualStudioWorkspace;
switch (e.Kind)
{
case WorkspaceChangeKind.SolutionAdded:
try
{
using (profiler.Step(WorkspaceChangeKind.SolutionAdded.ToString()))
{
await _indexingQueue.EnqueueMultipleAsync(workspace.CurrentSolution.Projects);
}
}
catch (Exception ex)
{
LogManager.GetLogger("error").Error(ex, "WorkspaceChangeKind.SolutionAdded");
await ThreadHelper.JoinableTaskFactory.SwitchToMainThreadAsync();
OutputWindowLogger.WriteLn($"Exception occured during adding solution: {ex.Message}");
}
break;
case WorkspaceChangeKind.SolutionChanged:
break;
case WorkspaceChangeKind.SolutionRemoved:
break;
case WorkspaceChangeKind.SolutionCleared:
break;
case WorkspaceChangeKind.SolutionReloaded:
break;
case WorkspaceChangeKind.ProjectAdded:
try
{
using (profiler.Step(WorkspaceChangeKind.SolutionAdded.ToString()))
{
await _indexingQueue.EnqueueMultipleAsync(workspace.CurrentSolution.Projects);
}
}
catch (Exception ex)
{
LogManager.GetLogger("error").Error(ex, "WorkspaceChangeKind.ProjectAdded");
OutputWindowLogger.WriteLn($"Exception occured during adding projects: {ex.Message}");
}
break;
case WorkspaceChangeKind.ProjectRemoved:
break;
case WorkspaceChangeKind.ProjectChanged:
break;
case WorkspaceChangeKind.ProjectReloaded:
break;
case WorkspaceChangeKind.DocumentAdded:
var documentAddedChanges = e.NewSolution.GetChanges(e.OldSolution);
var addedDocuments = documentAddedChanges.GetProjectChanges()
.SelectMany(x => x.GetAddedDocuments())
.Select(x => workspace.CurrentSolution.GetDocument(x));
await DocumentsAddedActionAsync(addedDocuments);
break;
case WorkspaceChangeKind.DocumentRemoved:
var documentRemovedChanges = e.NewSolution.GetChanges(e.OldSolution);
var removedDocuments = documentRemovedChanges.GetProjectChanges()
.SelectMany(x => x.GetRemovedDocuments());
await DocumentRemovedActionAsync(removedDocuments);
break;
case WorkspaceChangeKind.DocumentReloaded:
break;
case WorkspaceChangeKind.DocumentChanged:
break;
case WorkspaceChangeKind.AdditionalDocumentAdded:
break;
case WorkspaceChangeKind.AdditionalDocumentRemoved:
break;
case WorkspaceChangeKind.AdditionalDocumentReloaded:
break;
case WorkspaceChangeKind.AdditionalDocumentChanged:
break;
default:
break;
}
await profiler.StopAsync();
}
/// <summary>
///
/// </summary>
protected override void Initialize()
{
base.Initialize();
InitializeDTE();
LogLevel logLevel = LogLevel.Info;
if (Debugger.IsAttached)
{
logLevel = LogLevel.Verbose;
}
logger = new OutputWindowLogger(dte, "TFS Productivity Pack", logLevel);
try
{
logger.Log("TFSProductivityPackage Initialize", LogLevel.Info);
commandService = GetService(typeof(IMenuCommandService)) as OleMenuCommandService;
ITFSConnection tfsConnection = new TFSConnection(dte, logger);
ITFSVersionControl tfsVersionControl = new TFSVersionControl(tfsConnection, dte, logger);
ITFSBuildService tfsBuildService = new TFSBuildService(tfsConnection, this, logger);
//showDeletedFilesCmd = new ToggleShowDeletedItemsCommand(
// commandService,
// logger,
// tfsVersionControl);
quickCompareCmd = new TFSQuickCompareCommand(
commandService,
logger,
tfsVersionControl);
findInSCEFromSolExpCmd = new FindInSCEFromSolExpCommand(
commandService,
logger,
dte,
tfsVersionControl);
findInSCEFromCodeWindowCmd = new FindInSCEFromCodeWindowCommand(
commandService,
logger,
dte,
tfsVersionControl);
findInSolExpFromCodeWindowCmd = new FindInSolExpFromCodeWindowCommand(
commandService,
logger,
dte);
compareToBranchCommand = new CompareToBranchCommand(
commandService,
logger,
tfsVersionControl);
branchBuildDefinitionCmd = new BranchBuildDefinitionCommand(
commandService,
logger,
tfsBuildService,
tfsVersionControl);
CommandID comapreToBranchMenuID = new CommandID(GuidList.guidTFSProductivityPackCmdSet, PkgCmdIDList.menuIdCompareToBranchMenu);
OleMenuCommand menuItem = new OleMenuCommand(null, comapreToBranchMenuID);
menuItem.BeforeQueryStatus += compareToBranchCommand.ParentMenuQueryStatus;
commandService.AddCommand(menuItem);
}
catch (Exception ex)
{
logger.Log(string.Format("Error initializing TFsProductivityPackage\n {0}", ex.ToString()), LogLevel.Error);
}
}
public OutputWindowLoggerTests()
{
_underTest = new OutputWindowLogger(Mock.Of <IOutputPaneProvider>(p => p.Get() == _pane.Object));
}
protected override async System.Threading.Tasks.Task InitializeAsync(CancellationToken cancellationToken, IProgress <ServiceProgressData> progress)
{
NLogConfigurationService.ConfigureNLog();
NLogConfigurationService.ConfigureMiniProfilerWithDefaultLogger();
Logger logger = LogManager.GetLogger("error");
logger.Info("Extension initalizing");
EnvDTE = await GetServiceAsync(typeof(DTE)) as DTE2;
Assumes.Present(EnvDTE);
DteSemaphore.Release();
Storage = new PackageStorage();
var componentModel = await GetServiceAsync(typeof(SComponentModel)) as IComponentModel;
Assumes.Present(componentModel);
//Initialize public components, initialize instances that are dependent on any component
TextManager = await GetServiceAsync(typeof(SVsTextManager)) as IVsTextManager;
EditorAdaptersFactory = componentModel.GetService <IVsEditorAdaptersFactoryService>();
DocumentNavigationInstance.InjectDTE(EnvDTE);
//Prepare package events
var indexingQueue = new ProjectIndexingQueue();
var workspaceEvents = new WorkspaceEvents(indexingQueue);
Workspace = componentModel.GetService <VisualStudioWorkspace>();
Workspace.WorkspaceChanged += (s, e) => ThreadHelper.JoinableTaskFactory.RunAsync(async() => await workspaceEvents.WorkspaceChangedAsync(s, e));
var indexingWorkflow = new IndexingWorkflow(Storage.IndexingWorkflowOptions, new ProjectItemRetreiver(EnvDTE), Storage);
_envDteEvents = EnvDTE.Events as Events2;
if (_envDteEvents != null)
{
ProjectItemEventsActions projectItemEvents = new ProjectItemEventsActions();
_envDteProjectItemsEvents = _envDteEvents.ProjectItemsEvents;
_envDteProjectItemsEvents.ItemAdded += projectItemEvents.ItemAdded;
_envDteProjectItemsEvents.ItemRemoved += projectItemEvents.ItemRemoved;
_envDteProjectItemsEvents.ItemRenamed += projectItemEvents.ItemRenamed;
EventHandlers.BuildEventsActions buildEvents = new EventHandlers.BuildEventsActions();
_buildEvents = _envDteEvents.BuildEvents;
_buildEvents.OnBuildBegin += buildEvents.OnBuildBegin;
}
var solutionEventsActions = new VSSolutionEventsActions(indexingWorkflow);
await ThreadHelper.JoinableTaskFactory.SwitchToMainThreadAsync();
await ResultWindowCommand.InitializeAsync(this);
OutputWindowLogger.Init(await GetServiceAsync(typeof(SVsOutputWindow)) as SVsOutputWindow);
IStatusBar = await GetServiceAsync(typeof(SVsStatusbar)) as IVsStatusbar;
var svsSolution = await GetServiceAsync(typeof(SVsSolution));
Solution = svsSolution as IVsSolution;
Assumes.Present(Solution);
await HandleSolutionAsync(svsSolution, solutionEventsActions, indexingQueue);
_solutionEventsHandler = new SolutionEventsHandler(solutionEventsActions);
Solution.AdviseSolutionEvents(_solutionEventsHandler, out _solutionEventsCookie);
await Goto.InitializeAsync(this);
await RenameModalWindowCommand.InitializeAsync(this);
await RenameCommand.InitializeAsync(this);
await PrettyPrintCommand.InitializeAsync(this);
}
