public RoslynCodeAnalysisHelper(IWpfTextView view, ITextDocument document, IVsTaskList tasks, DTE2 dte, SVsServiceProvider serviceProvider, IVsActivityLog log)
{
_view = view;
_document = document;
_text = new Adornment();
_tasks = tasks;
_serviceProvider = serviceProvider;
_log = log;
_dispatcher = Dispatcher.CurrentDispatcher;
_adornmentLayer = view.GetAdornmentLayer(RoslynCodeAnalysisFactory.LayerName);
_view.ViewportHeightChanged += SetAdornmentLocation;
_view.ViewportWidthChanged += SetAdornmentLocation;
_text.MouseUp += (s, e) => dte.ExecuteCommand("View.ErrorList");
_timer = new Timer(750);
_timer.Elapsed += (s, e) =>
{
_timer.Stop();
System.Threading.Tasks.Task.Run(() =>
{
_dispatcher.Invoke(new Action(() => Update(false)), DispatcherPriority.ApplicationIdle, null);
});
};
_timer.Start();
}
protected PackageLog(string source, IVsActivityLog activityLog)
{
if (source == null)
throw new ArgumentNullException("source");
if (activityLog == null)
throw new ArgumentNullException("activityLog");
Source = source;
ActivityLog = activityLog;
}
public InterpreterLog([Import(typeof(SVsServiceProvider))]IServiceProvider provider) {
_activityLog = (IVsActivityLog)provider.GetService(typeof(SVsActivityLog));
}
/// <summary>
/// 包的初始化；这个方法将在包被选址后调用，所以你可以把所有
/// 基于Visual Studio提供服务的初始化代码放在这儿。
/// </summary>
protected override void Initialize()
{
base.Initialize();
ToolboxInitialized += new EventHandler(ToolboxItemPackage_ToolboxInitialized);
this.ToolboxUpgraded += new EventHandler(ToolboxItemPackage_ToolboxUpgraded);
// 初始化服务.
vsActivityLog = GetService(typeof(SVsActivityLog)) as IVsActivityLog;
vsToolbox2 = GetService(typeof(SVsToolbox)) as IVsToolbox2;
LogEntry(__ACTIVITYLOG_ENTRYTYPE.ALE_INFORMATION,
string.Format("Entering initializer for: {0}", this.ToString()));
// 添加工具箱项，如果它不存在.
try
{
if (!VerifyToolboxTabExist())
{
AddToolboxTab();
}
if (!VerifyToolboxItemExist())
{
AddToolboxItem();
}
}
catch (Exception ex)
{
LogEntry(__ACTIVITYLOG_ENTRYTYPE.ALE_ERROR, ex.Message);
LogEntry(__ACTIVITYLOG_ENTRYTYPE.ALE_ERROR, ex.StackTrace);
}
}
public static void LogWarning(this IVsActivityLog logger, string packageName, string message)
{
logger.LogEntry((UInt32)__ACTIVITYLOG_ENTRYTYPE.ALE_WARNING, packageName, message);
}
public ActivityLogAdapter(IVsActivityLog log, string sourceName)
{
_log = log;
_sourceName = sourceName;
}
/// <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 async Task InitializeAsync(CancellationToken token, IProgress <ServiceProgressData> progress)
{
try
{
_componentModel = await GetServiceAsync <SComponentModel, IComponentModel>();
CredentialsStore = _componentModel.GetService <ICredentialsStore>();
ExportProvider mefExportProvider = _componentModel.DefaultExportProvider;
_shellUtilsLazy = mefExportProvider.GetExport <IShellUtils>();
_gcpOutputWindowLazy = mefExportProvider.GetExport <IGcpOutputWindow>();
_processService = mefExportProvider.GetExport <IProcessService>();
_statusbarService = mefExportProvider.GetExport <IStatusbarService>();
_userPromptService = mefExportProvider.GetExport <IUserPromptService>();
_dataSourceFactory = mefExportProvider.GetExport <IDataSourceFactory>();
Dte = await GetServiceAsync <SDTE, DTE2>();
// Remember the package.
Instance = this;
// Activity log utils, to aid in debugging.
IVsActivityLog activityLog = await GetServiceAsync <SVsActivityLog, IVsActivityLog>();
await activityLog.LogInfoAsync("Starting Google Cloud Tools.");
// Register the command handlers.
await Task.WhenAll(
CloudExplorerCommand.InitializeAsync(this, token),
ManageAccountsCommand.InitializeAsync(this, token),
PublishProjectMainMenuCommand.InitializeAsync(this, token),
PublishProjectContextMenuCommand.InitializeAsync(this, token),
LogsViewerToolWindowCommand.InitializeAsync(this, token),
GenerateConfigurationContextMenuCommand.InitializeAsync(this, token),
ErrorReportingToolWindowCommand.InitializeAsync(this, token));
// Update the installation status of the package.
await CheckInstallationStatusAsync();
// Ensure the commands UI state is updated when the GCP project changes.
CredentialsStore.CurrentProjectIdChanged += (o, e) => ShellUtils.InvalidateCommandsState();
// With this setting we allow more concurrent connections from each HttpClient instance created
// in the process. This will allow all GCP API services to have more concurrent connections with
// GCP servers. The first benefit of this is that we can upload more concurrent files to GCS.
ServicePointManager.DefaultConnectionLimit = MaximumConcurrentConnections;
IVsRegisterUIFactories registerUIFactories =
await GetServiceAsync <SVsUIFactory, IVsRegisterUIFactories>();
var controlFactory = _componentModel.GetService <GcpMenuBarControlFactory>();
await registerUIFactories.RegisterUIFactoryAsync(controlFactory, token);
}
catch (Exception e)
{
IVsActivityLog activityLog = await GetServiceAsync <SVsActivityLog, IVsActivityLog>();
await activityLog.LogErrorAsync(e.Message);
await activityLog.LogErrorAsync(e.StackTrace);
}
}
public LogService(IThreadingContext threadingContext, IVsActivityLog activityLog)
: base(threadingContext)
{
_activityLog = activityLog;
}
public VsActivityLogger(SVsServiceProvider serviceProvider, IVsfTelemetry telemetry)
{
this.telemetry = telemetry;
this.activityLog = serviceProvider.GetService(typeof(SVsActivityLog)) as IVsActivityLog;
}
internal static void Initialize(IVsActivityLog log)
{
mInstance = log;
}
public ActivityLogger(IVsActivityLog log) {
_log = log;
}
internal static void Initialize(IVsActivityLog log)
{
mInstance = log;
}
public PrigActivityLog(IVsActivityLog activityLog)
: base("Prig", activityLog)
{ }
public VisualStudioActivityLogAppender(IServiceProvider serviceProvider)
{
_log = serviceProvider.GetService(typeof(SVsActivityLog)) as IVsActivityLog;
Source = typeof (VisualStudioActivityLogAppender).Name;
}
protected override void Initialize()
{
// determine whether we're running the experimental instance.
_isExperimental = false;
string[] args = Environment.GetCommandLineArgs();
if (args.Length >= 3 && args[2].Equals("exp", StringComparison.OrdinalIgnoreCase))
{
_isExperimental = true;
}
// get the product version
IVsExtensionManager manager = GetService(typeof(SVsExtensionManager)) as IVsExtensionManager;
IInstalledExtension myExtension = manager.GetInstalledExtension(PackageId);
if (myExtension != null)
{
ProductVersion = myExtension.Header.Version;
}
// Initialize NLog
if (LogManager.Configuration == null)
{
string path = Path.Combine(SettingsDirectory, string.Format("{0}_NLog.config", PackageName));
if (!File.Exists(path))
{
// Get the template from resources and write it to the directory.
if (!Directory.Exists(SettingsDirectory))
{
Directory.CreateDirectory(SettingsDirectory);
}
File.WriteAllText(path, GetDefaultNLogConfigFileContents());
}
if (File.Exists(path))
{
LogManager.Configuration = new XmlLoggingConfiguration(path);
// Register for changes to the config file
LogManager.ConfigurationChanged += LogManager_ConfigurationChanged;
}
}
// Get the current logger now, since we have the configuration
_logger = LogManager.GetCurrentClassLogger();
_logger.Trace("VS arguments: [{0}]", string.Join(",", args));
var componentManager = _compMgr = (IOleComponentManager)GetService(typeof(SOleComponentManager));
OLECRINFO[] crinfo = new OLECRINFO[1];
crinfo[0].cbSize = (uint)Marshal.SizeOf(typeof(OLECRINFO));
crinfo[0].grfcrf = (uint)_OLECRF.olecrfNeedIdleTime;
crinfo[0].grfcadvf = (uint)_OLECADVF.olecadvfModal | (uint)_OLECADVF.olecadvfRedrawOff | (uint)_OLECADVF.olecadvfWarningsOff;
crinfo[0].uIdleTimeInterval = 0;
ErrorHandler.ThrowOnFailure(componentManager.FRegisterComponent(this, crinfo, out _componentID));
_activityLog = GetService(typeof(SVsActivityLog)) as IVsActivityLog;
base.Initialize();
Instance = this;
_packageDTEEvents = ApplicationObject.Events.DTEEvents;
_packageDTEEvents.OnBeginShutdown += OnBeginShutdown;
}
public VisualStudioActivityLogger(IVsActivityLog vsActivityLog)
{
_vsActivityLog = vsActivityLog;
}
public InterpreterLog([Import(typeof(SVsServiceProvider))] IServiceProvider provider)
{
_activityLog = (IVsActivityLog)provider.GetService(typeof(SVsActivityLog));
}
/// <summary>
/// Default ctor
/// </summary>
/// <param name="package"></param>
public SpriteContainer(AsyncPackage package)
{
_package = package;
ThreadHelper.ThrowIfNotOnUIThread();
var settingsManager = new ShellSettingsManager(ServiceProvider.GlobalProvider);
_userSettingsStore = settingsManager.GetWritableSettingsStore(SettingsScope.UserSettings);
InitializeComponent();
this.Owner = Application.Current.MainWindow;
this.Topmost = false;
#region Register event handlers
if (package == null)
{
throw new ArgumentException("Package was null");
}
IVsActivityLog activityLog = package.GetServiceAsync(typeof(SVsActivityLog))
.ConfigureAwait(true).GetAwaiter().GetResult() as IVsActivityLog;
//if (activityLog == null) return;
//System.Windows.Forms.MessageBox.Show("Found the activity log service.");
ThreadHelper.ThrowIfNotOnUIThread();
DTE dte = (DTE)package.GetServiceAsync(typeof(DTE)).ConfigureAwait(true).GetAwaiter().GetResult();
events = dte.Events;
docEvents = dte.Events.DocumentEvents;
buildEvents = dte.Events.BuildEvents;
RegisterToDTEEvents();
Owner.LocationChanged += Owner_LocationChanged;
Owner.StateChanged += Owner_StateOrSizeChanged;
Owner.SizeChanged += Owner_StateOrSizeChanged;
LocationChanged += SpriteContainer_LocationChanged;
#endregion
#region -- Restore Sprite postion --
double?storedRelativeTop = null;
double?storedRelativeLeft = null;
double relativeTop = 0;
double relativeLeft = 0;
try
{
if (_userSettingsStore.PropertyExists(Constants.SettingsCollectionPath, nameof(RelativeTop)))
{
storedRelativeTop = double.Parse(_userSettingsStore.GetString(Constants.SettingsCollectionPath, nameof(RelativeTop)), CultureInfo.InvariantCulture);
}
if (_userSettingsStore.PropertyExists(Constants.SettingsCollectionPath, nameof(RelativeLeft)))
{
storedRelativeLeft = Double.Parse(_userSettingsStore.GetString(Constants.SettingsCollectionPath, nameof(RelativeLeft)), CultureInfo.InvariantCulture);
}
}
catch (Exception e)
{
Debug.Fail(e.Message);
}
if (!storedRelativeTop.HasValue || !storedRelativeLeft.HasValue)
{
recalculateSpritePosition(out relativeTop, out relativeLeft, true);
storedRelativeTop = relativeTop;
storedRelativeLeft = relativeLeft;
this.RelativeLeft = relativeLeft;
this.RelativeTop = relativeTop;
storeRelativeSpritePosition(storedRelativeTop.Value, storedRelativeLeft.Value);
}
else
{
recalculateSpritePosition(out relativeTop, out relativeLeft);
this.RelativeLeft = relativeLeft;
this.RelativeTop = relativeTop;
}
double ownerTop = this.Owner.Top;
double ownerLeft = this.Owner.Left;
if (this.Owner.WindowState == WindowState.Maximized)
{
ownerTop = 0;
ownerLeft = 0;
}
this.Top = ownerTop + storedRelativeTop.Value;
this.Left = ownerLeft + storedRelativeLeft.Value;
#endregion
var values = Enum.GetValues(typeof(ClippyAnimation));
//// TEMP: create a voice for each animation in the context menu
//var pMenu = (ContextMenu)this.Resources["cmButton"];
//foreach (ClippySingleAnimation val in values)
//{
// var menuItem = new MenuItem()
// {
// Header = val.ToString(),
// Name = "cmd" + val.ToString()
// };
// menuItem.Click += cmdTestAnimation_Click;
// pMenu.Items.Add(menuItem);
//}
//// /TEMP
_clippy = new Clippy((Canvas)FindName("ClippyCanvas"));
_clippy.StartAnimation(ClippyAnimation.Idle1_1);
}
/// <summary>
/// Initializes a new <see cref="ActivityLogger"/>.
/// </summary>
/// <param name="activityLog">The Visual Studio activity log</param>
/// <param name="logType">The type a logger is for</param>
public ActivityLogger(IVsActivityLog activityLog, Type logType)
{
_activityLog = activityLog;
_logType = logType;
}
/// <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()
{
try
{
Trace.WriteLine(string.Format(CultureInfo.CurrentCulture, "Entering Initialize() of: {0}", this));
base.Initialize();
// InitializePackageServices
_dte = (DTE2)GetGlobalService(typeof(DTE));
_log = GetService(typeof(SVsActivityLog)) as IVsActivityLog;
// Initialize Tools->Options Page
_options = (OptionsPageGeneral)GetDialogPage(typeof(OptionsPageGeneral));
// Initialize Solution Service Events
_solutionService = (IVsSolution2)GetGlobalService(typeof(SVsSolution));
if (_solutionService != null)
{
_solutionService.AdviseSolutionEvents(this, out _solutionEventsCookie);
}
_debuggerEvents = (EnvDTE.DebuggerEvents)_dte.Events.DebuggerEvents;
_debuggerEvents.OnEnterRunMode += new _dispDebuggerEvents_OnEnterRunModeEventHandler(OnEnterRunMode); ;
_debuggerEvents.OnEnterDesignMode += new _dispDebuggerEvents_OnEnterDesignModeEventHandler(OnEnterDesignMode); ;
//InitializeOutputWindowPane
if (_dte != null
&& _dte.ToolWindows.OutputWindow.OutputWindowPanes.Cast<OutputWindowPane>().All(p => p.Name != _options.OutputPane))
{
_dte.ToolWindows.OutputWindow.OutputWindowPanes.Add(_options.OutputPane);
}
InitializeMenus();
InitializeAutoShelve();
}
catch (Exception ex)
{
WriteException(ex);
}
}
private static void LogException(
IVsActivityLog log,
string message,
string path,
Exception ex,
IEnumerable<object> data = null
) {
if (log == null) {
return;
}
var fullMessage = string.Format("{1}:{0}{2}{0}{3}",
Environment.NewLine,
message,
ex,
data == null ? string.Empty : string.Join(Environment.NewLine, data)
).Trim();
if (string.IsNullOrEmpty(path)) {
log.LogEntry(
(uint)__ACTIVITYLOG_ENTRYTYPE.ALE_ERROR,
"Python Tools",
fullMessage
);
} else {
log.LogEntryPath(
(uint)__ACTIVITYLOG_ENTRYTYPE.ALE_ERROR,
"Python Tools",
fullMessage,
path
);
}
}
public async Task QuickRefreshNodesGlyphs(IVsSccProject2 project, List <string> files)
{
try
{
if (files.Count > 0)
{
string[] rgpszFullPaths = new string[files.Count];
for (int i = 0; i < files.Count; i++)
{
rgpszFullPaths[i] = files[i];
}
VsStateIcon[] rgsiGlyphs = new VsStateIcon[files.Count];
uint[] rgdwSccStatus = new uint[files.Count];
GetSccGlyph(files.Count, rgpszFullPaths, rgsiGlyphs, rgdwSccStatus);
uint[] rguiAffectedNodes = new uint[files.Count];
//TODO We could/Should cache this mapping !!!!
await ThreadHelper.JoinableTaskFactory.SwitchToMainThreadAsync();
IList <uint> subnodes = await SolutionExtensions.GetProjectItems((IVsHierarchy)project, VSConstants.VSITEMID_ROOT);
var dict = new Dictionary <string, uint>();
var proj = project as IVsProject2;
foreach (var id in subnodes)
{
string docname;
var res = proj.GetMkDocument(id, out docname);
if (res == VSConstants.S_OK && !string.IsNullOrEmpty(docname))
{
dict[docname] = id;
}
}
for (int i = 0; i < files.Count; ++i)
{
uint id;
if (dict.TryGetValue(files[i], out id))
{
rguiAffectedNodes[i] = id;
}
}
await ThreadHelper.JoinableTaskFactory.SwitchToMainThreadAsync();
project.SccGlyphChanged(files.Count, rguiAffectedNodes, rgsiGlyphs, rgdwSccStatus);
}
}
catch (Exception ex)
{
await ThreadHelper.JoinableTaskFactory.SwitchToMainThreadAsync();
IVsActivityLog log = _sccProvider.GetService(typeof(SVsActivityLog)) as IVsActivityLog;
if (log == null)
{
return;
}
int hr = log.LogEntry((UInt32)__ACTIVITYLOG_ENTRYTYPE.ALE_ERROR,
ex.StackTrace,
string.Format(CultureInfo.CurrentCulture,
"Called for: {0}", this.ToString()));
}
}
private static void LoadOneProvider(
string codebase,
HashSet<string> seen,
List<ComposablePartCatalog> catalog,
IVsActivityLog log
) {
if (string.IsNullOrEmpty(codebase)) {
return;
}
if (!seen.Add(codebase)) {
return;
}
if (log != null) {
log.LogEntryPath(
(uint)__ACTIVITYLOG_ENTRYTYPE.ALE_INFORMATION,
"Python Tools",
"Loading interpreter provider assembly",
codebase
);
}
AssemblyCatalog assemblyCatalog = null;
const string FailedToLoadAssemblyMessage = "Failed to load interpreter provider assembly";
try {
assemblyCatalog = new AssemblyCatalog(codebase);
} catch (Exception ex) {
LogException(log, FailedToLoadAssemblyMessage, codebase, ex);
}
if (assemblyCatalog == null) {
return;
}
const string FailedToLoadMessage = "Failed to load interpreter provider";
try {
catalog.Add(assemblyCatalog);
} catch (Exception ex) {
LogException(log, FailedToLoadMessage, codebase, ex);
}
}
public VisualStudioActivityLogger(IVsActivityLog vsActivityLog)
{
_vsActivityLog = vsActivityLog;
}
public InterpreterOptionsService([Import(typeof(SVsServiceProvider), AllowDefault = true)] IServiceProvider provider) {
_serviceThread = Thread.CurrentThread;
#if !DEV12_OR_LATER
_serviceContext = SynchronizationContext.Current;
#endif
_settings = SettingsManagerCreator.GetSettingsManager(provider);
if (provider != null) {
_activityLog = provider.GetService(typeof(SVsActivityLog)) as IVsActivityLog;
} else if (ServiceProvider.GlobalProvider != null) {
_activityLog = ServiceProvider.GlobalProvider.GetService(typeof(SVsActivityLog)) as IVsActivityLog;
}
Initialize(provider);
InitializeDefaultInterpreterWatcher(provider);
}
private void InitializeActivityLog()
{
this.activityLog = (IVsActivityLog)GetService(typeof(SVsActivityLog));
}
public PrigActivityLog(IVsActivityLog activityLog)
: base("Prig", activityLog)
{
}
public static void LogInformation(this IVsActivityLog logger, string packageName, string message)
{
logger.LogEntry((UInt32)__ACTIVITYLOG_ENTRYTYPE.ALE_INFORMATION, packageName, message);
}
/// <summary>
/// The event explorer user control constructor.
/// </summary>
public RdtEventControl()
{
InitializeComponent();
// Create a selection container for tracking selected RDT events.
selectionContainer = new MsVsShell.SelectionContainer();
// Advise the RDT of this event sink.
IOleServiceProvider sp =
Package.GetGlobalService(typeof(IOleServiceProvider)) as IOleServiceProvider;
if (sp == null)
{
return;
}
rdt = new RunningDocumentTable(new ServiceProvider(sp));
if (rdt == null)
{
return;
}
rdtCookie = rdt.Advise(this);
// Obtain the single instance of the options via automation.
try
{
DTE dte = (DTE)Package.GetGlobalService(typeof(DTE));
Properties props =
dte.get_Properties("RDT Event Explorer", "Explorer Options");
IOptions o = props.Item("ContainedOptions").Object as IOptions;
options = (Options)o;
}
catch
{
IVsActivityLog log = Package.GetGlobalService(
typeof(SVsActivityLog)) as IVsActivityLog;
if (log != null)
{
log.LogEntry(
(uint)__ACTIVITYLOG_ENTRYTYPE.ALE_INFORMATION,
ToString(),
string.Format(CultureInfo.CurrentCulture,
"RdtEventExplorer could not obtain properties via automation: {0}",
ToString())
);
}
options = new Options();
}
// Prepare the event grid.
eventGrid.AutoGenerateColumns = false;
eventGrid.AllowUserToAddRows = false;
eventGrid.SelectionMode = DataGridViewSelectionMode.FullRowSelect;
eventGrid.Columns.Add("Event", Resources.EventHeader);
eventGrid.Columns.Add("Moniker", Resources.MonikerHeader);
eventGrid.Columns["Event"].ReadOnly = true;
eventGrid.Columns["Moniker"].ReadOnly = true;
eventGrid.AllowUserToResizeRows = false;
eventGrid.AllowUserToResizeColumns = true;
eventGrid.AutoSizeColumnsMode = DataGridViewAutoSizeColumnsMode.Fill;
int x = Screen.PrimaryScreen.Bounds.Size.Width;
int y = Screen.PrimaryScreen.Bounds.Size.Height;
Size = new Size(x / 3, y / 3);
}
public LogService(IVsActivityLog activityLog)
{
_activityLog = activityLog;
}
private void UpdateIncludesOnBeforeSave(VCProject p, string projectDirectory)
{
var(includesSaved, macrosSaved) = ProjectIncludesManager.CheckSavedIncludesAndMacros(p);
IEnumerable <string> includesBefore = null;
IEnumerable <CompilerMacroResult> macrosBefore = null;
try
{
ThreadHelper.JoinableTaskFactory.Run("Updating includes and macros", async(progress) =>
{
await Task.Run(() => GetIncludesAndMacros());
void GetIncludesAndMacros()
{
if (!includesSaved)
{
progress.Report(new ThreadedWaitDialogProgressData("Fetching project information"));
ProjectInformationCommandResult projectInformationBefore = null;
try
{
projectInformationBefore = cliCommunication.ExecuteCommand(Resources.Command_get_project_information, null,
typeof(ProjectInformationCommandResult), Resources.Option_get_project_information_project,
$"\"{projectDirectory}\"") as ProjectInformationCommandResult;
}
catch (PlcncliException ex)
{
projectInformationBefore = cliCommunication.ConvertToTypedCommandResult <ProjectInformationCommandResult>(ex.InfoMessages);
}
includesBefore = projectInformationBefore?.IncludePaths.Select(x => x.PathValue);
if (includesBefore == null)
{
includesBefore = Enumerable.Empty <string>();
}
}
if (!macrosSaved)
{
progress.Report(new ThreadedWaitDialogProgressData("Fetching compiler information"));
CompilerSpecificationCommandResult compilerSpecsBefore = null;
try
{
compilerSpecsBefore = cliCommunication.ExecuteCommand(Resources.Command_get_compiler_specifications, null,
typeof(CompilerSpecificationCommandResult), Resources.Option_get_compiler_specifications_project,
$"\"{projectDirectory}\"") as CompilerSpecificationCommandResult;
}
catch (PlcncliException ex)
{
compilerSpecsBefore = cliCommunication.ConvertToTypedCommandResult <CompilerSpecificationCommandResult>(ex.InfoMessages);
}
macrosBefore = compilerSpecsBefore?.Specifications.FirstOrDefault()
?.CompilerMacros.Where(m => !m.Name.StartsWith("__has_include(")) ?? Enumerable.Empty <CompilerMacroResult>();
}
}
});
this.vcProject = p;
this.projectDirectory = p.ProjectDirectory;
this.wrapper = new IncludesAndMacrosWrapper(includesBefore, macrosBefore);
}
catch (Exception e)
{
Reset();
try
{
ThreadHelper.ThrowIfNotOnUIThread();
IVsActivityLog log = Package.GetGlobalService(typeof(SVsActivityLog)) as IVsActivityLog;
log.LogEntry((uint)__ACTIVITYLOG_ENTRYTYPE.ALE_ERROR, this.ToString(),
"An error occurred while updating the includes: " + e.Message + e.StackTrace);
}
catch (Exception) { /*try to log error in activity log*/ }
}
}
/// <summary>
/// Set up Visual Studio activity logger.
/// </summary>
private void SetUpActivityLogger() {
SrcMLFileLogger.DefaultLogger.Info("> Set up Visual Studio activity logger.");
ActivityLog = GetService(typeof(SVsActivityLog)) as IVsActivityLog;
if(null == ActivityLog) {
Trace.WriteLine("Can not get the Activity Log service.");
}
}
public VsLogger(ServiceAccessor serviceAccessor, JoinableTaskFactory joinableTaskFactory)
{
_logger = serviceAccessor.GetService(typeof(SVsActivityLog)) as IVsActivityLog;
_joinableTaskFactory = joinableTaskFactory;
}
public LogService(IVsActivityLog activityLog)
{
_activityLog = activityLog;
}
public void Initialize(IVsActivityLog log)
{
_log = log;
}
