/////////////////////////////////////////////////////////////////////////////
// Overridden Package Implementation
#region Package Members
/// <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>
protected override void Initialize()
{
Debug.WriteLine(string.Format(CultureInfo.CurrentCulture, "Entering Initialize() of: {0}", ToString()));
base.Initialize();
// Add our command handlers for menu (commands must exist in the .vsct file)
var mcs = GetService(typeof(IMenuCommandService)) as OleMenuCommandService;
if (null != mcs)
{
// Create the command for the menu item.
var menuCommandID = new CommandID(GuidList.guidGitHubExtensionCmdSet, (int)PkgCmdIDList.cmdidNewIssue);
var menuItem = new MenuCommand(MenuItemCallback, menuCommandID);
mcs.AddCommand(menuItem);
// Create the commands for the tool windows
var issueListWndCommandID = new CommandID(GuidList.guidGitHubExtensionCmdSet, (int)PkgCmdIDList.cmdidIssues);
var menuIssueListWin = new MenuCommand(ShowIssueListToolWindow, issueListWndCommandID);
mcs.AddCommand(menuIssueListWin);
var issueWndCommandID = new CommandID(GuidList.guidGitHubExtensionCmdSet, (int)PkgCmdIDList.cmdidIssueWindow);
var menuIssueWin = new MenuCommand(ShowIssueToolWindow, issueWndCommandID);
mcs.AddCommand(menuIssueWin);
}
IComponentModel componentModel = (IComponentModel)GetService(typeof(SComponentModel));
IOutputWindowService outputWindowService = componentModel.DefaultExportProvider.GetExportedValueOrDefault <IOutputWindowService>();
IOutputWindowPane gitHubPane = null;
// Warn users if dependencies aren't installed.
vsbaseWarningProvider = new ErrorListProvider(this);
if (outputWindowService != null)
{
gitHubPane = outputWindowService.TryGetPane(View.OutputWriter.GitHubOutputWindowPaneName);
}
else
{
ErrorTask task = new ErrorTask
{
Category = TaskCategory.Misc,
ErrorCategory = TaskErrorCategory.Error,
Text = "The required VSBase Services debugging support extension is not installed; output window messages will not be shown. Click here for more information."
};
task.Navigate += HandleNavigateToVsBaseServicesExtension;
vsbaseWarningProvider.Tasks.Add(task);
vsbaseWarningProvider.Show();
}
// This code is a bit of a hack to bridge MEF created components and Ninject managed components
Factory.Rebind <IOutputWindowPane>().ToConstant(gitHubPane);
Factory.Rebind <ICache>().ToConstant(componentModel.DefaultExportProvider.GetExportedValue <Cache>());
}
internal InfoSquigglesTagger(
ITextBuffer buffer,
ITagAggregator <AsmTokenTag> aggregator,
AsmSimulator asmSimulator)
{
//AsmDudeToolsStatic.Output(string.Format("INFO: LabelErrorTagger: constructor"));
this._sourceBuffer = buffer;
this._aggregator = aggregator;
this._errorListProvider = AsmDudeTools.Instance.Error_List_Provider;
this._asmSimulator = asmSimulator;
this._foreground = AsmDudeToolsStatic.GetFontColor();
this._asmSimulator.Simulate_Done_Event += this.Handle_Simulate_Done_Event;
}
protected override void Initialize()
{
BuildCommand.Initialize(this);
FlatBufferCode.Editor.BuildCommand.Initialize(this);
dte = ServiceProvider.GlobalProvider.GetService(typeof(DTE)) as DTE;
//dte.Events.BuildEvents.OnBuildBegin += BuildEvents_OnBuildBegin;
ErrorList = new ErrorListProvider(this);
outputWindow = ServiceProvider.GlobalProvider.GetService(typeof(IVsOutputWindow)) as IVsOutputWindow;
base.Initialize();
}
public ErrorListUpdateSuspensionContext()
{
Lock.EnterWriteLock();
lock (Sync)
{
if (Interlocked.Increment(ref _activeSuspensionRequestCount) < 0)
{
Interlocked.Exchange(ref _activeSuspensionRequestCount, 1);
}
}
ErrorListProvider.SuspendRefresh();
}
public JsHintRunner(string fileName)
{
_fileName = fileName;
if (_providers.ContainsKey(fileName))
{
_provider = _providers[fileName];
}
else
{
_provider = new ErrorListProvider(EditorExtensionsPackage.Instance);
_providers.Add(fileName, _provider);
}
}
public void Dispose()
{
Lock.ExitWriteLock();
lock (Sync)
{
if (Interlocked.Decrement(ref _activeSuspensionRequestCount) > 0)
{
return;
}
}
ErrorListProvider.ResumeRefresh();
}
public OutputConsoleLogger(IServiceProvider serviceProvider)
{
ErrorListProvider = new ErrorListProvider(serviceProvider);
var outputConsoleProvider = ServiceLocator.GetInstance <IOutputConsoleProvider>();
_dte = ServiceLocator.GetInstance <DTE>();
_buildEvents = _dte.Events.BuildEvents;
_buildEvents.OnBuildBegin += (obj, ev) => { ErrorListProvider.Tasks.Clear(); };
_solutionEvents = _dte.Events.SolutionEvents;
_solutionEvents.AfterClosing += () => { ErrorListProvider.Tasks.Clear(); };
OutputConsole = outputConsoleProvider.CreateOutputConsole(requirePowerShellHost: false);
}
public static void AddErrors(string file, IEnumerable <CompilerError> errors)
{
CleanErrors(file);
ErrorListProvider provider = new ErrorListProvider(WebCompilerPackage.Package);
foreach (var error in errors)
{
var task = CreateTask(error, provider);
provider.Tasks.Add(task);
}
_providers.Add(file, provider);
}
public static void Initialize(IServiceProvider serviceProvider)
{
try
{
_ivsSolution = (IVsSolution)Package.GetGlobalService(typeof(IVsSolution));
_ivsErrorList = (IVsErrorList)Package.GetGlobalService(typeof(SVsErrorList));
_errorListProvider = new ErrorListProvider(serviceProvider);
_initialized = true;
}
catch (Exception exception)
{
Log.Error($"Failed to initialize Error List. {exception.Message}");
}
}
internal ResolverTagger(ITextBuffer buffer, IServiceProvider serviceProvider, ITextDocumentFactoryService textDocumentFactory)
{
_buffer = buffer;
if (!textDocumentFactory.TryGetTextDocument(_buffer, out _document))
{
_document = null;
}
Snapshot = null; // this makes sure the next snapshot will look different
_errorProvider = new ErrorListProvider(serviceProvider);
_filename = _document != null ? _document.FilePath : "<program>";
BufferIdleEventUtil.AddBufferIdleEventListener(_buffer, ResolveBuffer);
this.RunResolver = true;
}
public ErrorTagger(ITextBuffer buffer, IBufferTagAggregatorFactoryService aggregatorFactory,
IServiceProvider svcp, ITextDocumentFactoryService textDocumentFactory, ITextView view)
{
_buffer = buffer;
_view = view;
_aggregator = aggregatorFactory.CreateTagAggregator <SchemeTag>(buffer);
textDocumentFactory.TryGetTextDocument(_buffer, out _document);
_errorProvider = new ErrorListProvider(svcp);
BufferIdleEventUtil.AddBufferIdleEventListener(_buffer, ReparseFile);
}
public static void Parse(ErrorListProvider errorListProvider, string path)
{
lock (errorListProvider)
{
// Remove all tasks for the current file, since they're likely out-of-date
// if the user has just saved
RemoveStaleErrors(errorListProvider, path);
// Show a message that we're executing; since this can be slow. Otherwise we'd
// have to leave known-stale errors, or empty list (which suggests no errors).
errorListProvider.Tasks.Add(new ErrorTask
{
ErrorCategory = TaskErrorCategory.Message,
Document = path,
Text = "Executing DartAnalyzer, please wait..."
});
}
IEnumerable <ErrorTask> errors;
try
{
errors = new DartAnalyzer().Analyze(path);
}
catch (Exception ex)
{
// Update the error list eith the new errors
lock (errorListProvider)
{
RemoveStaleErrors(errorListProvider, path);
errorListProvider.Tasks.Add(new ErrorTask(new Exception("Unable to execute DartAnalzyer: " + ex.ToString())));
errorListProvider.Show();
return;
}
}
// Update the error list eith the new errors
lock (errorListProvider)
{
RemoveStaleErrors(errorListProvider, path);
foreach (var error in errors)
{
error.Navigate += (s, e) => errorListProvider.Navigate(error, new Guid(EnvDTE.Constants.vsViewKindCode));
errorListProvider.Tasks.Add(error);
}
errorListProvider.Show();
}
}
/// <summary>
/// Initializes a new instance of the <see cref="TransformationPreviewLogger"/> class.
/// </summary>
/// <param name="errorListProvider">The VS Package</param>
/// <param name="hierachy">The current project hierarchy</param>
public TransformationPreviewLogger(ErrorListProvider errorListProvider, IVsHierarchy hierachy)
{
if (errorListProvider == null)
{
throw new ArgumentNullException(nameof(errorListProvider));
}
if (hierachy == null)
{
throw new ArgumentNullException(nameof(hierachy));
}
this.errorListProvider = errorListProvider;
this.hierachy = hierachy;
}
internal LabelErrorTagger(
ITextBuffer buffer,
ITagAggregator<AsmTokenTag> aggregator,
ILabelGraph labelGraph)
{
//AsmDudeToolsStatic.Output(string.Format("INFO: LabelErrorTagger: constructor"));
this._sourceBuffer = buffer;
this._aggregator = aggregator;
this._errorListProvider = AsmDudeTools.Instance.Error_List_Provider;
this._labelGraph = labelGraph;
this._foreground = AsmDudeToolsStatic.GetFontColor();
this._labelGraph.Reset_Done_Event += this.Handle_Label_Graph_Reset_Done_Event;
this._labelGraph.Reset_Delayed();
}
public static void Initialize(IServiceProvider provider, DTE _dte)
{
dte = _dte;
if (errorListProvider != null)
{
return;
}
errorListProvider = new ErrorListProvider(provider);
errorListProvider.ProviderGuid = Guid.Parse("7C2C89EC-D368-4B15-B93A-E506EEA449E4");
errorListProvider.ProviderName = "Naggy.DiagnosticsProvider";
documentEvents = dte.Events.DocumentEvents;
documentEvents.DocumentClosing += new _dispDocumentEvents_DocumentClosingEventHandler(documentEvents_DocumentClosing);
}
public static void AddErrors(string file, IEnumerable <MinificationError> errors)
{
CleanErrors(file);
// Ideally we want to remove this dependency down the road
ErrorListProvider provider = new ErrorListProvider(BundlerMinifierPackage._instance);
foreach (var error in errors)
{
var task = CreateTask(error, provider);
provider.Tasks.Add(task);
}
_providers.Add(file, provider);
}
public static void GotoBookmark(ConcurrentDictionary <int, Bookmark> dico, int keyNumber)
{
if (dico == null)
{
dico = _dico;
}
Bookmark bmk;
ITextBuffer buffer;
IWpfTextView wpfView;
if (dico.TryGetValue(keyNumber, out bmk))
{
var dte = NumberedBookmarksPackage.Instance.DTE;
for (int i = 0; i < dte.Documents.Count; i++)
{
var doc = dte.Documents.Item(i + 1);
if (DocumentUtilities.GetTextBufferAndView(dte, doc, out buffer, out wpfView))
{
if (buffer == bmk.Buffer)
{
doc.Activate();
try
{
var pos = bmk.TrackingPoint.GetPosition(buffer.CurrentSnapshot);
var newSnap = new SnapshotPoint(buffer.CurrentSnapshot, pos);
wpfView.Caret.MoveTo(newSnap);
wpfView.DisplayTextLineContainingBufferPosition(newSnap, wpfView.ViewportHeight / 2, ViewRelativePosition.Top);
}
catch (Exception ex)
{
//send exception into task list window
var errorProvider = new ErrorListProvider(NumberedBookmarksPackage.Instance);
var t = new ErrorTask(ex);
t.Line = bmk.Line;
t.Column = 1;
t.Document = doc.Name;
t.Text = string.Format(CultureInfo.InvariantCulture, "Unable to go to bookmark #{0} : {1}", keyNumber, ex);
errorProvider.Tasks.Add(t);
}
}
}
}
}
else
{
SetStatusText(string.Format("the bookmark '{0}' has no been pinned in document or document has been closed, press ctrl-shift-{0} to assign location", keyNumber));
}
}
public void VsTextViewCreated(IVsTextView textViewAdapter)
{
IWpfTextView view = AdaptersFactory.GetWpfTextView(textViewAdapter);
view.TextBuffer.Properties.GetOrCreateSingletonProperty(() => view);
_errorList = view.TextBuffer.Properties.GetOrCreateSingletonProperty(() => new ErrorListProvider(ServiceProvider));
if (_errorList == null)
return;
CommandFilter filter = new CommandFilter(view, CompletionBroker);
textViewAdapter.AddCommandFilter(filter, out var next);
filter.Next = next;
view.Closed += OnViewClosed;
}
public TaskList(object application)
{
instance = this;
this.app = application as DTE2;
var app = application as Microsoft.VisualStudio.OLE.Interop.IServiceProvider;
if (app != null)
{
this.serviceProvider = new ServiceProvider(app);
this.listProvider = new ErrorListProvider(this.serviceProvider);
this.listProvider.ProviderName = this.GetType().Assembly.FullName;
this.listProvider.ProviderGuid = new Guid("F1415C4C-5D67-401F-A81C-71F0721BB6F0");
this.listProvider.Show();
}
}
private static ErrorListProvider InitializeErrorListProvider()
{
var errorListProvider = new ErrorListProvider(EditorExtensionsPackage.Instance);
try
{
errorListProvider.ProviderName = "Unused CSS Browser Link Extension";
errorListProvider.ProviderGuid = new Guid("5BA8BB0D-D518-45ae-966C-864C536454F2");
}
catch
{
errorListProvider.Dispose();
}
return(errorListProvider);
}
protected override void DisposeManagedResources()
{
if (this.textView.TextBuffer != null)
{
this.textView.TextBuffer.Changed -= this.OnBufferChanged;
}
this.ClearErrors();
Validate.IsNotNull(this.errorListProvider, nameof(this.errorListProvider));
this.errorListProvider.Dispose();
this.errorListProvider = null;
base.DisposeManagedResources();
}
public TextViewMonitor(IWpfTextView view, ITextDocument document, DTE app, ErrorListProvider messageList)
{
_view = view;
_doc = document;
_app = app;
_settingsManager = new SettingsManager(view, document, messageList);
_settings = _settingsManager.Settings;
if (_settings != null)
{
_globalSettings = new GlobalSettings(view, app, _settings);
_view.GotAggregateFocus += ViewOnGotAggregateFocus;
}
document.FileActionOccurred += FileActionOccurred;
view.Closed += Closed;
}
private TransformProjectFilesCommand(
Package package, ErrorListProvider errorListProvider,
IVsOutputWindowPane outputWindowPane, IVsStatusbar statusbar, IOptions options)
{
m_package = package ?? throw new ArgumentNullException(nameof(package));
m_errorListProvider = errorListProvider ?? throw new ArgumentNullException(nameof(errorListProvider));
m_outputWindowPane = outputWindowPane ?? throw new ArgumentNullException(nameof(outputWindowPane));
m_statusbar = statusbar ?? throw new ArgumentNullException(nameof(statusbar));
m_options = options ?? throw new ArgumentNullException(nameof(options));
if (ServiceProvider.GetService(typeof(IMenuCommandService)) is OleMenuCommandService commandService)
{
var menuCommandID = new CommandID(CommandSet, CommandId);
var menuItem = new MenuCommand(async(s, e) => await InvokeRefactoring(s, e), menuCommandID);
commandService.AddCommand(menuItem);
}
}
/// <summary>
/// Initializes a new instance of the <see cref="NugetPacker"/> 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 NugetPacker(Package package)
{
this.package = package ?? throw new ArgumentNullException("package");
errorList = new ErrorListProvider(this.package);
ivsSolution = (IVsSolution)Package.GetGlobalService(typeof(IVsSolution));
if (ServiceProvider.GetService(typeof(IMenuCommandService)) is OleMenuCommandService commandService)
{
var menuCommandID = new CommandID(CommandSet, CommandId);
var menuItem = new MenuCommand(MenuItemCallback, menuCommandID);
commandService.AddCommand(menuItem);
NugetPackerLogic.OnCompleted += NugetPackerLogic_OnCompleted;
NugetPackerLogic.OnException += NugetPackerLogic_OnException;
}
}
public TypescriptWatcher(VSPackage package, IVsOutputWindowPane pane)
{
if (package == null)
{
throw new ArgumentNullException(nameof(package));
}
_vsOutWindow = pane ?? throw new ArgumentNullException(nameof(pane));
_runningDocumentTable = new RunningDocumentTable(package);
_runningDocumentTable.Advise(this);
_errorList = new ErrorListProvider(package)
{
ProviderName = $"{Symbol.Name} Error List",
ProviderGuid = new Guid("e18abe6a-7968-4bd6-9266-0684b1d50e7a")
};
}
public MarginBase(string source, string name, string contentType, bool showMargin, ITextDocument document)
{
Document = document;
_marginName = name;
_settingsKey = _marginName + "_width";
_showMargin = showMargin;
_dispatcher = Dispatcher.CurrentDispatcher;
_provider = new ErrorListProvider(EditorExtensionsPackage.Instance);
Document.FileActionOccurred += Document_FileActionOccurred;
if (showMargin)
{
_dispatcher.BeginInvoke(
new Action(() => Initialize(contentType, source)), DispatcherPriority.ApplicationIdle, null);
}
}
public SassWatcher(VSPackage package, IVsOutputWindowPane pane)
{
if (package == null)
{
throw new ArgumentNullException(nameof(package));
}
_vsOutWindow = pane ?? throw new ArgumentNullException(nameof(pane));
_runningDocumentTable = new RunningDocumentTable(package);
_runningDocumentTable.Advise(this);
_errorList = new ErrorListProvider(package)
{
ProviderName = $"{Metadata.ProductName} Error List",
ProviderGuid = new Guid("6e63fa03-9f4e-47da-9cf9-5efd22799c28")
};
}
internal ErrorTagger(ITextBuffer buffer, IBufferTagAggregatorFactoryService aggregatorFactory, IServiceProvider serviceProvider, ITextDocumentFactoryService textDocumentFactory)
{
_buffer = buffer;
_aggregator = aggregatorFactory.CreateTagAggregator <PkgDefTokenTag>(buffer);
if (!textDocumentFactory.TryGetTextDocument(_buffer, out _document))
{
_document = null;
}
_errorProvider = new ErrorListProvider(serviceProvider);
ReparseFile(null, EventArgs.Empty);
BufferIdleEventUtil.AddBufferIdleEventListener(_buffer, ReparseFile);
}
void Remove(ErrorTask task)
{
if (ErrorListProvider != null)
{
ErrorListProvider.RemoveTask(task);
}
Tasks.Remove(task);
lock (TaskProjects)
{
if (TaskProjects.ContainsKey(task))
{
TaskProjects.Remove(task);
}
}
}
public ProjectInfo(
NemerleProjectNode projectNode,
IVsHierarchy hierarchy,
NemerleLanguageService languageService,
string fileName,
string location
)
{
ErrorHelper.ThrowIsNull(languageService, "languageService");
ErrorHelper.ThrowIsNull(projectNode, "projectNode");
ErrorHelper.ThrowIsNull(hierarchy, "hierarchy");
Debug.Assert(projectNode.Site != null);
LanguageService = languageService;
_errorList = new ErrorListProvider(languageService.Site);
ProjectFullPath = Path.GetFullPath(fileName);
_projectNode = projectNode;
_hierarchy = hierarchy;
_engine = EngineFactory.Create(this, new TraceWriter(), false); // it enables parser working.
Engine.TypedtreeCreated += delegate
{
_buildTypedtreeCount++;
AstToolWindow tool = AstToolWindow.AstTool;
if (tool != null)
{
tool.BuildTypedtreeCount = _buildTypedtreeCount;
}
};
if (!string.IsNullOrEmpty(location))
{
_projectLocation = location;
}
else
{
_projectLocation = Path.GetDirectoryName(fileName);
}
if (!_projectLocation.EndsWith("\\"))
{
_projectLocation += "\\";
}
}
private ErrorListProvider GetErrorListProvider() {
if (null == _errorListProvider) {
_errorListProvider = new ErrorListProvider(_projectNode.ProjectMgr.Site);
}
return _errorListProvider;
}
