private void OnReplaceClick(object sender, EventArgs e)
{
if (dte != null)
{
outputWindow?.OutputString($"Updating project versions to {txtVersion.Text}.\r\n");
var fileNames = GetProjectAssemblyInfoFiles();
if (!fileNames.Any())
{
outputWindow?.OutputString("No AssemblyInfo.cs found in any project. " +
"Lightweight solution load might be enabled. " +
"Please disable lightweight solution load and try again.\r\n");
}
else
{
var increaseVersion = CreateIncreaseVersion(txtVersion.Text);
foreach (var fileName in fileNames)
{
outputWindow?.OutputString(fileName + "\r\n");
increaseVersion.Files.Add(new File(fileName));
}
increaseVersion.Execute();
outputWindow?.OutputString("Project versions updated.\r\n");
}
}
this.Close();
}
/// <inheritdoc/>
public override async TPL.Task Execute(Project project)
{
string projName = project.UniqueName;
bool needInstall = true;
lock (SyncObject)
{
needInstall = InstallTasks.Add(projName);
}
if (needInstall)
{
string warningTitle = this.IsUpdate ? Resources.Resources.NugetUpdate_Title : Resources.Resources.NugetInstall_Title;
string warningMessage = this.IsUpdate ? Resources.Resources.NugetUpdate_Text : Resources.Resources.NugetInstall_Text;
if (await this.HasUserAcceptedWarningMessage(warningTitle, warningMessage))
{
// Gets the general output pane to inform user of installation
IVsOutputWindowPane outputWindow = (IVsOutputWindowPane)await this.Package.GetServiceAsync(typeof(SVsGeneralOutputWindowPane));
outputWindow?.OutputString(string.Format(CultureInfo.CurrentCulture, Resources.Resources.NugetInstall_InstallingOutput, project.Name) + Environment.NewLine);
this.Package.JoinableTaskFactory.RunAsync(async() =>
{
await TPL.TaskScheduler.Default;
string outputMessage = Resources.Resources.NugetInstall_FinishedOutput;
try
{
await this.Successor.Execute(project);
}
catch
{
outputMessage = Resources.Resources.NugetInstall_ErrorOutput;
throw;
}
finally
{
lock (SyncObject)
{
InstallTasks.Remove(projName);
}
await this.Package.JoinableTaskFactory.SwitchToMainThreadAsync();
outputWindow?.OutputString(string.Format(CultureInfo.CurrentCulture, outputMessage, project.Name) + Environment.NewLine);
}
}).Task.Forget();
}
else
{
lock (SyncObject)
{
// If the user refuses to install, the task should not be added
InstallTasks.Remove(projName);
}
}
}
}
private void BackgroundInstallSlowCheetah(Project project)
{
string projName = project.UniqueName;
bool needInstall = true;
lock (this.syncObject)
{
needInstall = this.installTasks.Add(projName);
}
if (needInstall)
{
if (this.HasUserAcceptedWarningMessage(Resources.Resources.NugetInstall_Title, Resources.Resources.NugetInstall_Text))
{
// Gets the general output pane to inform user of installation
IVsOutputWindowPane outputWindow = (IVsOutputWindowPane)this.package.GetService(typeof(SVsGeneralOutputWindowPane));
outputWindow?.OutputString(string.Format(Resources.Resources.NugetInstall_InstallingOutput, project.Name) + Environment.NewLine);
// Uninstalls the older version (if present) and installs latest package
var componentModel = (IComponentModel)this.package.GetService(typeof(SComponentModel));
IVsPackageInstaller2 packageInstaller = componentModel.GetService <IVsPackageInstaller2>();
TPL.Task.Run(() =>
{
string outputMessage = Resources.Resources.NugetInstall_FinishedOutput;
try
{
packageInstaller.InstallLatestPackage(null, project, PackageName, false, false);
}
catch
{
outputMessage = Resources.Resources.NugetInstall_ErrorOutput;
throw;
}
finally
{
lock (this.syncObject)
{
this.installTasks.Remove(projName);
}
ThreadHelper.Generic.BeginInvoke(() => outputWindow?.OutputString(string.Format(outputMessage, project.Name) + Environment.NewLine));
}
});
}
else
{
lock (this.syncObject)
{
// If the user refuses to install, the task should not be added
this.installTasks.Remove(projName);
}
}
}
}
/// <inheritdoc/>
public override void Execute(Project project)
{
string projName = project.UniqueName;
bool needInstall = true;
lock (SyncObject)
{
needInstall = InstallTasks.Add(projName);
}
if (needInstall)
{
string warningTitle = this.IsUpdate ? Resources.Resources.NugetUpdate_Title : Resources.Resources.NugetInstall_Title;
string warningMessage = this.IsUpdate ? Resources.Resources.NugetUpdate_Text : Resources.Resources.NugetInstall_Text;
if (this.HasUserAcceptedWarningMessage(warningTitle, warningMessage))
{
// Gets the general output pane to inform user of installation
IVsOutputWindowPane outputWindow = (IVsOutputWindowPane)this.Package.GetService(typeof(SVsGeneralOutputWindowPane));
outputWindow?.OutputString(string.Format(Resources.Resources.NugetInstall_InstallingOutput, project.Name) + Environment.NewLine);
TPL.Task.Run(() =>
{
string outputMessage = Resources.Resources.NugetInstall_FinishedOutput;
try
{
this.Successor.Execute(project);
}
catch
{
outputMessage = Resources.Resources.NugetInstall_ErrorOutput;
throw;
}
finally
{
lock (SyncObject)
{
InstallTasks.Remove(projName);
}
ThreadHelper.Generic.BeginInvoke(() => outputWindow?.OutputString(string.Format(outputMessage, project.Name) + Environment.NewLine));
}
});
}
else
{
lock (SyncObject)
{
// If the user refuses to install, the task should not be added
InstallTasks.Remove(projName);
}
}
}
}
internal static async Task OutputWindowPaneAsync(string message)
{
await ThreadHelper.JoinableTaskFactory.SwitchToMainThreadAsync();
IVsOutputWindowPane outputPane = null;
var outputWindow = ServiceProvider.GlobalProvider.GetService(typeof(SVsOutputWindow)) as IVsOutputWindow;
if (outputWindow != null && ErrorHandler.Failed(outputWindow.GetPane(ActionOutputWindowPane, out outputPane)))
{
IVsWindowFrame windowFrame;
var vsUiShell = ServiceProvider.GlobalProvider.GetService(typeof(SVsUIShell)) as IVsUIShell;
if (vsUiShell != null)
{
uint flags = (uint)__VSFINDTOOLWIN.FTW_fForceCreate;
vsUiShell.FindToolWindow(flags, VSConstants.StandardToolWindows.Output, out windowFrame);
windowFrame.Show();
}
outputWindow.CreatePane(ActionOutputWindowPane, "Actions", 1, 1);
outputWindow.GetPane(ActionOutputWindowPane, out outputPane);
outputPane.Activate();
}
outputPane?.OutputString(message);
}
/// <summary>
/// Prints messages to the package manager output window
/// </summary>
/// <param name="message">Message to print</param>
/// <param name="pane">Pane object</param>
public static void PrintOutput(string message, IVsOutputWindowPane pane)
{
if(pane != null)
{
ErrorHandler.ThrowOnFailure(pane.OutputString(message + "\n"));
}
}
public void WriteLine(string output)
{
Microsoft.VisualStudio.Shell.ThreadHelper.ThrowIfNotOnUIThread();
TryCreateOutputPane();
_outputPane?.OutputString($"{output}{Environment.NewLine}");
}
private async Task OutputMessageAsync(string message, bool clear = false)
{
await ThreadHelper.JoinableTaskFactory.SwitchToMainThreadAsync();
IVsOutputWindowPane outputPane = null;
IVsWindowFrame windowFrame = null;
var outputWindow = ServiceProvider.GlobalProvider.GetService(typeof(SVsOutputWindow)) as IVsOutputWindow;
if (outputWindow != null && ErrorHandler.Failed(outputWindow.GetPane(windowGuid, out outputPane)))
{
outputWindow.CreatePane(windowGuid, "Meadow Device Explorer", 1, 1);
outputWindow.GetPane(windowGuid, out outputPane);
}
var vsUiShell = ServiceProvider.GlobalProvider.GetService(typeof(SVsUIShell)) as IVsUIShell;
uint flags = (uint)__VSFINDTOOLWIN.FTW_fForceCreate;
vsUiShell?.FindToolWindow(flags, VSConstants.StandardToolWindows.Output, out windowFrame);
if (clear)
{
outputPane?.Clear();
}
windowFrame?.Show();
outputPane?.Activate();
outputPane?.OutputString($"[{DateTime.Now.ToLocalTime()}] {message}" + Environment.NewLine);
}
public static void Write(string message)
{
ThreadHelper.ThrowIfNotOnUIThread();
IVsOutputWindow outWindow = Package.GetGlobalService(typeof(SVsOutputWindow)) as IVsOutputWindow;
Guid generalPaneGuid = VSConstants.GUID_OutWindowDebugPane; // P.S. There's also the GUID_OutWindowDebugPane available.
IVsOutputWindowPane generalPane = null;
outWindow?.GetPane(ref generalPaneGuid, out generalPane);
generalPane?.OutputString(Environment.NewLine);
generalPane?.OutputString(message);
generalPane?.OutputString(Environment.NewLine);
if (_isFirstTime)
{
_isFirstTime = false;
generalPane?.Activate();
}
}
public static void OutputMessageToPane(string message)
{
Microsoft.VisualStudio.Shell.ThreadHelper.ThrowIfNotOnUIThread();
if (currentPane == null)
{
CreatePane();
}
currentPane?.OutputString(message + "\n");
}
public static void ReportError(string error)
{
var outWindow = Package.GetGlobalService(typeof(SVsOutputWindow)) as IVsOutputWindow;
outWindow?.CreatePane(ref ErrorOutputGuid, ErrorOutputTitle, 1, 1);
// ReSharper disable once InlineOutVariableDeclaration
IVsOutputWindowPane customPane = null;
outWindow?.GetPane(ref ErrorOutputGuid, out customPane);
customPane?.OutputString($"ERROR: {error}");
customPane?.Activate(); // Brings this pane into view
}
/// <summary>Log the error to the Output Window.</summary>
public static async Task LogAsync(this Exception exception)
{
try
{
await ThreadHelper.JoinableTaskFactory.SwitchToMainThreadAsync();
if (await EnsurePaneAsync())
{
_pane?.OutputString(exception + Environment.NewLine);
}
}
catch
{
// Swallow the exception
}
}
public static void Log(object message)
{
try
{
ThreadHelper.ThrowIfNotOnUIThread();
if (_pane == null)
{
var guid = Guid.NewGuid();
_output.CreatePane(ref guid, _name, 1, 1);
_output.GetPane(ref guid, out _pane);
}
_pane?.OutputString($"{DateTime.Now}: {message}{Environment.NewLine}");
}
catch (Exception ex)
{
Debug.Write(ex);
}
}
public static void WriteToGeneral(string text)
{
const int VISIBLE = 1;
const int DO_NOT_CLEAR_WITH_SOLUTION = 0;
// Get the output window
var outputWindow = Instance.GetService(typeof(SVsOutputWindow)) as IVsOutputWindow;
// The General pane is not created by default. We must force its creation
var guidPane = VSConstants.OutputWindowPaneGuid.GeneralPane_guid;
var hr = outputWindow.CreatePane(guidPane, "General", VISIBLE, DO_NOT_CLEAR_WITH_SOLUTION);
ErrorHandler.ThrowOnFailure(hr);
// Get the pane
IVsOutputWindowPane outputWindowPane = null;
hr = outputWindow.GetPane(guidPane, out outputWindowPane);
ErrorHandler.ThrowOnFailure(hr);
// Output the text
outputWindowPane?.Activate();
outputWindowPane?.OutputString(text);
}
public override MSBuildResult Build(uint vsopts, string config, IVsOutputWindowPane output, string target)
{
if (output != null)
{
output.OutputString("Build for node.js project is not required.\n");
}
return MSBuildResult.Successful;
}
public void Log(string message)
{
outputWindow.OutputString(message + "\r\n");
}
public override void Write(string value)
{
Dispatcher.CurrentDispatcher.VerifyAccess();
ErrorHandler.ThrowOnFailure(m_outputPane.OutputString(value));
}
private static void RefreshStackData(int pid)
{
DirectoryInfo taskDirectory = new DirectoryInfo(Path.GetTempPath());
FileInfo[] taskFiles = taskDirectory.GetFiles("pmip_" + pid + "_*.txt");
if (taskFiles.Length < 1)
{
return;
}
Array.Sort(taskFiles, (a, b) => GetFileNameSequenceNum(a.Name).CompareTo(GetFileNameSequenceNum(b.Name)));
var fileName = taskFiles[taskFiles.Length - 1].FullName;
if (_currentFile != fileName)
{
DisposeStreams();
try
{
_fileStream = new FileStream(fileName, FileMode.Open, FileAccess.Read, FileShare.ReadWrite | FileShare.Delete);
_fileStreamReader = new StreamReader(_fileStream);
_currentFile = fileName;
var versionStr = _fileStreamReader.ReadLine();
const char delimiter = ':';
var tokens = versionStr.Split(delimiter);
if (tokens.Length != 2)
{
throw new Exception("Failed reading input file " + fileName + ": Incorrect format");
}
var version = double.Parse(tokens[1]);
if (version > 1.0)
{
throw new Exception("Failed reading input file " + fileName + ": A newer version of UnityMixedCallstacks plugin is required to read this file");
}
}
catch (Exception ex)
{
_debugPane.OutputString("Unable to read dumped pmip file: " + ex.Message + "\n");
DisposeStreams();
_enabled = false;
return;
}
}
try
{
string line;
while ((line = _fileStreamReader.ReadLine()) != null)
{
const char delemiter = ';';
var tokens = line.Split(delemiter);
//should never happen, but lets be safe and not get array out of bounds if it does
if (tokens.Length != 3)
{
continue;
}
var startip = tokens[0];
var endip = tokens[1];
var description = tokens[2];
var startiplong = ulong.Parse(startip, NumberStyles.HexNumber);
var endipint = ulong.Parse(endip, NumberStyles.HexNumber);
_rangesSortedByIp.Add(new Range()
{
Name = description, Start = startiplong, End = endipint
});
}
}
catch (Exception ex)
{
_debugPane.OutputString("Unable to read dumped pmip file: " + ex.Message + "\n");
DisposeStreams();
_enabled = false;
return;
}
_rangesSortedByIp.Sort((r1, r2) => r1.Start.CompareTo(r2.Start));
}
public static async Task <Report> ProcessAsync(IAsyncServiceProvider serviceProvider, bool addComment)
{
await ThreadHelper.JoinableTaskFactory.SwitchToMainThreadAsync();
var report = new Report();
var dte = (DTE)await serviceProvider.GetServiceAsync(typeof(DTE));
if (dte == null || string.IsNullOrEmpty(dte.Solution.FullName))
{
report.SolutionName = "N/A";
return(report);
}
report.SolutionName = System.IO.Path.GetFileNameWithoutExtension(System.IO.Path.GetFileName(dte.Solution.FullName));
IVsStatusbar statusBar = (IVsStatusbar)await serviceProvider.GetServiceAsync(typeof(SVsStatusbar));
IVsThreadedWaitDialogFactory factory =
(IVsThreadedWaitDialogFactory)await serviceProvider.GetServiceAsync(
typeof(SVsThreadedWaitDialogFactory));
IVsThreadedWaitDialog2 dialog = null;
factory?.CreateInstance(out dialog);
dialog?.StartWaitDialog("PVSStudio Helper", (addComment) ? "Add comment" : "Remove comment", null, null,
null, 0, false, true);
IVsOutputWindow outWindow =
(IVsOutputWindow)await serviceProvider.GetServiceAsync(typeof(SVsOutputWindow));
var generalPaneGuid = VSConstants.GUID_OutWindowGeneralPane; // P.S. There's also the GUID_OutWindowDebugPane available.
IVsOutputWindowPane generalPane = null;
outWindow?.GetPane(ref generalPaneGuid, out generalPane);
if (generalPane == null)
{
outWindow?.CreatePane(ref generalPaneGuid, "General", 1, 0);
outWindow?.GetPane(ref generalPaneGuid, out generalPane);
}
await ProjectProcess.ProcessAsync(dte, report, addComment, async (message) =>
{
await ThreadHelper.JoinableTaskFactory.SwitchToMainThreadAsync();
dialog?.UpdateProgress(null, message, null, 0, 0, true, out var canceled);
//messagePump.WaitText = message;
if (statusBar != null)
{
statusBar.IsFrozen(out var isFrozen);
if (isFrozen == 0)
{
statusBar.SetText(message);
}
}
generalPane?.OutputString($"{message}{Environment.NewLine}");
});
var finalMessage =
$"The solution {report.SolutionName} processed. Processed items: {report.ProcessedItems}, include opened items {report.ProcessedOpenedItems}";
if (statusBar != null)
{
statusBar.IsFrozen(out var isFrozen);
if (isFrozen == 0)
{
statusBar.SetText(finalMessage);
}
}
generalPane?.OutputStringThreadSafe($"{finalMessage}{Environment.NewLine}");
dialog.EndWaitDialog();
return(report);
}
// Write text to output pane or logfile
override public void WriteToLog(string Text)
{
GeneralOutputWindowPane.OutputString(Text + "\n");
}
internal override void BuildAsync(uint vsopts, string config, IVsOutputWindowPane output, string target, Action<MSBuildResult, string> uiThreadCallback)
{
if (output != null)
{
output.OutputString("Build for node.js project is not required.\n");
}
uiThreadCallback(MSBuildResult.Successful, target);
}
internal void OutputMessage(string message)
{
m_buildOutputPane.OutputString(string.Format(CultureInfo.InvariantCulture, "{0}{1}", message, Environment.NewLine));
// Check whether this message represents an error or a warning and push to task itemlist accordingly
ErrorTask task = null;
string fileName = null;
Match match = null;
foreach (Regex regex in m_messageRegexs)
{
match = regex.Match(message);
if (match.Success)
{
break;
}
}
if (match != null && match.Success)
{
fileName = match.Groups["file"].Value;
var lineNumber = int.Parse(match.Groups["linestart"].Value, CultureInfo.InvariantCulture);
var colNumber = int.Parse(match.Groups["columnstart"].Value, CultureInfo.InvariantCulture);
var errOrWarning = match.Groups["level"].Value;
var isAnError = string.Equals(errOrWarning, "error", StringComparison.OrdinalIgnoreCase);
if (isAnError)
{
m_numErrors++;
}
task = new ErrorTask
{
Document = fileName,
Line = lineNumber - 1,
Column = colNumber - 1,
Text = match.Groups["message"].Value,
Priority = isAnError ? TaskPriority.High : TaskPriority.Normal,
ErrorCategory = isAnError ? TaskErrorCategory.Error : TaskErrorCategory.Warning,
Category = TaskCategory.BuildCompile,
};
}
else
{
// If the standard pattern is not followed for errors
if (message.StartsWith("error ", StringComparison.OrdinalIgnoreCase) ||
message.StartsWith("error:", StringComparison.OrdinalIgnoreCase))
{
task = new ErrorTask
{
Text = message,
Priority = TaskPriority.High,
ErrorCategory = TaskErrorCategory.Error,
Category = TaskCategory.BuildCompile,
};
}
}
// Add the task (if not null) to error list
if (task != null)
{
if (!string.IsNullOrEmpty(fileName))
{
// populating the project hierarchy to show the project name in the error list window
IVsUIHierarchy vsHierarchy;
uint itemId;
Microsoft.VisualStudio.OLE.Interop.IServiceProvider serviceProvider;
var docInProj = 0;
var docOpenResult = m_shellOpenDocument.IsDocumentInAProject(
fileName,
out vsHierarchy,
out itemId,
out serviceProvider,
out docInProj);
if (docInProj != 0 && docOpenResult == VSConstants.S_OK)
{
task.HierarchyItem = vsHierarchy;
}
}
// Adding navigation handler
task.Navigate += NavigateTo;
m_errorListProvider.Tasks.Add(task);
}
}
private void OutputLine(string Message)
{
m_OutputWindow.OutputString(Message + Environment.NewLine);
Trace.WriteLine(Message, k_ExtensionName);
}
/// <summary>
/// This function is the callback used to execute the command when the menu item is clicked.
/// See the constructor to see how the menu item is associated with this function using
/// OleMenuCommandService service and MenuCommand class.
/// </summary>
/// <param name="sender">Event sender.</param>
/// <param name="e">Event args.</param>
private async void Execute(object sender, EventArgs e)
{
await ThreadHelper.JoinableTaskFactory.SwitchToMainThreadAsync();
DTE dte = (DTE)await this.ServiceProvider.GetServiceAsync(typeof(DTE));
foreach (SelectedItem item in dte.SelectedItems)
{
ProjectItem pi = item.ProjectItem;
string tarsPath = null;
switch (pi.ContainingProject.CodeModel.Language)
{
case CodeModelLanguageConstants.vsCMLanguageCSharp:
tarsPath = this.tars2csPath;
break;
case CodeModelLanguageConstants.vsCMLanguageVC:
break;
default:
break;
}
if (tarsPath != null)
{
string srcFile = pi.FileNames[0];
string tmpFile = Path.GetTempPath() + pi.GetHashCode() + ".tars";
File.Copy(srcFile, tmpFile, true);
string targetPath = srcFile + "_";
string path = Path.GetTempPath() + pi.GetHashCode();
if (Directory.Exists(path))
{
Directory.Delete(path, true);
}
Directory.CreateDirectory(path);
ProjectItems pis = pi.Collection;
try
{
pis.Item(pi.Name + "_").Delete();
}
catch
{
}
if (Directory.Exists(targetPath))
{
Directory.Delete(targetPath, true);
}
pi = pis.AddFolder(pi.Name + "_");
ProcessStartInfo psi = new ProcessStartInfo(tarsPath, $"--base-package= \"{tmpFile}\"");
psi.UseShellExecute = false;
psi.CreateNoWindow = true;
psi.WorkingDirectory = path;
psi.RedirectStandardError = true;
using (Process p = Process.Start(psi))
{
if (p?.WaitForExit(10 * 1000) == true)
{
IVsOutputWindowPane outputPane = (IVsOutputWindowPane)await this.ServiceProvider.GetServiceAsync(typeof(SVsGeneralOutputWindowPane));
outputPane.OutputString(p.StandardError.ReadToEnd());
//string targetPath = Path.GetDirectoryName(srcFile);
this.AddLinks(pi, path, targetPath);
}
}
Directory.Delete(path, true);
File.Delete(tmpFile);
}
}
}
private void WriteToPaneLog(string text)
{
pane.OutputString(text);
}
/// <summary>
/// Writes text to the Output window pane.
/// </summary>
/// <param name="value">The text to write.</param>
public override void Write(string value)
{
ThreadHelper.ThrowIfNotOnUIThread();
_pane.OutputString(value);
}
private void Output(string text)
{
pane.OutputString(text);
}
private void OutputToOutputWindow(string message)
{
_pane?.OutputString(message + Environment.NewLine);
}
private void WriteToOutputPane(string message)
{
_outputPane.OutputString(message + Environment.NewLine);
_outputPane.Activate();
}
private void WriteLineToOutputWindow(string text)
{
ThreadHelper.ThrowIfNotOnUIThread();
_vsOutputWindowPane.OutputString(text + Environment.NewLine);
}
/// <summary>
/// Sends a text string into pane.
/// </summary>
/// <param name="text"></param>
public void OutputString(string text)
{
pane.OutputString(text);
}
/// <summary>
/// Initialization of the package; this method is called right after the package is sited, so this is the place
/// where you can put all the initialization code that rely on services provided by VisualStudio.
/// </summary>
/// <param name="cancellationToken">A cancellation token to monitor for initialization cancellation, which can occur when VS is shutting down.</param>
/// <param name="progress">A provider for progress updates.</param>
/// <returns>A task representing the async work of package initialization, or an already completed task if there is none. Do not return null from this method.</returns>
protected override async Task InitializeAsync(CancellationToken cancellationToken, IProgress <ServiceProgressData> progress)
{
// When initialized asynchronously, the current thread may be a background thread at this point.
// Do any initialization that requires the UI thread after switching to the UI thread.
await this.JoinableTaskFactory.SwitchToMainThreadAsync(cancellationToken);
_dte = await GetServiceAsync(typeof(EnvDTE.DTE)) as EnvDTE.DTE;
if (_dte == null)
{
return;
}
// Intercept build commands
string[] buildCommandNames = new[]
{
"Build.BuildSolution",
"Build.RebuildSolution",
"Build.BuildSelection",
"Build.RebuildSelection",
"ClassViewContextMenus.ClassViewProject.Build",
"ClassViewContextMenus.ClassViewProject.Rebuild",
"Build.ProjectPickerBuild",
"Build.ProjectPickerRebuild",
"Build.BuildOnlyProject",
"Build.RebuildOnlyProject"
};
_cmdEvents = new List <CommandEvents>();
foreach (string buildCommandName in buildCommandNames)
{
var buildCommand = _dte.Commands.Item(buildCommandName);
var cmdev = _dte.Events.CommandEvents[buildCommand.Guid, buildCommand.ID];
cmdev.BeforeExecute += this.BuildCommand_BeforeExecute;
_cmdEvents.Add(cmdev);
}
_dte.Events.SolutionEvents.BeforeClosing += SolutionEvents_BeforeClosing;
_dte.Events.BuildEvents.OnBuildBegin += BuildEvents_OnBuildBegin;
_dte.Events.BuildEvents.OnBuildDone += BuildEvents_OnBuildDone;
_dte.Events.BuildEvents.OnBuildProjConfigBegin += BuildEvents_OnBuildProjConfigBegin;
_rdt = (IVsRunningDocumentTable)(await GetServiceAsync(typeof(SVsRunningDocumentTable)));
_rdt.AdviseRunningDocTableEvents(this, out _rdtCookie);
await AdMaiora.RealXaml.Extension.Commands.EnableRealXamlCommand.InitializeAsync(this, _dte);
await AdMaiora.RealXaml.Extension.Commands.DisableRealXamlCommand.InitializeAsync(this, _dte);
CreateOutputPane();
try
{
string currentPath = Path.GetDirectoryName(GetType().Assembly.Location);
_assemblyResolver = new ManualAssemblyResolver(
Assembly.LoadFile(Path.Combine(currentPath, "Newtonsoft.Json.dll")),
Assembly.LoadFile(Path.Combine(currentPath, "System.Buffers.dll")),
Assembly.LoadFile(Path.Combine(currentPath, "System.Numerics.Vectors.dll"))
);
}
catch (Exception ex)
{
System.Diagnostics.Debug.WriteLine(ex);
_outputPane.OutputString("Something went wrong loading assemblies.");
_outputPane.OutputString(ex.ToString());
}
UpdateManager.Current.IdeRegistered += this.UpdateManager_IdeRegistered;
UpdateManager.Current.ClientRegistered += this.UpdateManager_ClientRegistered;
UpdateManager.Current.PageAppeared += this.UpdateManager_PageAppeared;
UpdateManager.Current.PageDisappeared += this.UpdateManager_PageDisappeared;
UpdateManager.Current.XamlUpdated += this.UpdateManager_XamlUpdated;
UpdateManager.Current.AssemblyLoaded += this.UpdateManager_AssemblyLoaded;
UpdateManager.Current.ExceptionThrown += this.UpdateManager_ExceptionThrown;
UpdateManager.Current.IdeNotified += this.Current_IdeNotified;
_xamlCache.Clear();
}
public void WriteAsync(XElement element)
{
debugPane.OutputString(element.ToString());
}
