public HostFactory(
IVim vim,
ITextBufferFactoryService bufferFactoryService,
ITextEditorFactoryService editorFactoryService,
IEditorOptionsFactoryService editorOptionsFactoryService,
IKeyBindingService keyBindingService,
SVsServiceProvider serviceProvider,
IVsEditorAdaptersFactoryService adaptersFactory,
IExternalEditorManager externalEditorManager,
IDisplayWindowBrokerFactoryService displayWindowBrokerFactoryService,
IVsAdapter adapter,
IProtectedOperations protectedOperations,
IVimBufferCoordinatorFactory bufferCoordinatorFactory)
{
_vim = vim;
_keyBindingService = keyBindingService;
_bufferFactoryService = bufferFactoryService;
_editorFactoryService = editorFactoryService;
_editorOptionsFactoryService = editorOptionsFactoryService;
_externalEditorManager = externalEditorManager;
_displayWindowBrokerFactoryServcie = displayWindowBrokerFactoryService;
_adaptersFactory = adaptersFactory;
_adapter = adapter;
_protectedOperations = protectedOperations;
_bufferCoordinatorFactory = bufferCoordinatorFactory;
}
internal SettingsMigrator(SVsServiceProvider serviceProvider, IVimApplicationSettings vimApplicationSettings, ILegacySettings legacySettings, [EditorUtilsImport] IProtectedOperations protectedOperations)
{
_dte = serviceProvider.GetService<SDTE, _DTE>();
_vimApplicationSettings = vimApplicationSettings;
_legacySettings = legacySettings;
_protectedOperations = protectedOperations;
}
public VisualStudioMetadataAsSourceFileSupportService(SVsServiceProvider serviceProvider, IMetadataAsSourceFileService metadataAsSourceFileService)
{
_metadataAsSourceFileService = metadataAsSourceFileService;
var solution = (IVsSolution)serviceProvider.GetService(typeof(SVsSolution));
ErrorHandler.ThrowOnFailure(solution.AdviseSolutionEvents(this, out _eventCookie));
}
public VisualStudioDocumentNavigationService(
SVsServiceProvider serviceProvider,
IVsEditorAdaptersFactoryService editorAdaptersFactoryService)
{
_serviceProvider = serviceProvider;
_editorAdaptersFactoryService = editorAdaptersFactoryService;
}
public VsTextViewListener(
IVsEditorAdaptersFactoryService editorAdaptersFactory,
SVsServiceProvider serviceProvider)
{
this.editorAdaptersFactory = editorAdaptersFactory;
this.serviceProvider = serviceProvider;
}
internal VsVimHost(
IVsAdapter adapter,
ITextBufferFactoryService textBufferFactoryService,
ITextEditorFactoryService textEditorFactoryService,
ITextDocumentFactoryService textDocumentFactoryService,
ITextBufferUndoManagerProvider undoManagerProvider,
IVsEditorAdaptersFactoryService editorAdaptersFactoryService,
IEditorOperationsFactoryService editorOperationsFactoryService,
ISmartIndentationService smartIndentationService,
ITextManager textManager,
ISharedServiceFactory sharedServiceFactory,
IVimApplicationSettings vimApplicationSettings,
SVsServiceProvider serviceProvider)
: base(textBufferFactoryService, textEditorFactoryService, textDocumentFactoryService, editorOperationsFactoryService)
{
_vsAdapter = adapter;
_editorAdaptersFactoryService = editorAdaptersFactoryService;
_dte = (_DTE)serviceProvider.GetService(typeof(_DTE));
_vsExtensibility = (IVsExtensibility)serviceProvider.GetService(typeof(IVsExtensibility));
_textManager = textManager;
_sharedService = sharedServiceFactory.Create();
_vsMonitorSelection = serviceProvider.GetService<SVsShellMonitorSelection, IVsMonitorSelection>();
_fontProperties = new TextEditorFontProperties(serviceProvider);
_vimApplicationSettings = vimApplicationSettings;
_smartIndentationService = smartIndentationService;
uint cookie;
_vsMonitorSelection.AdviseSelectionEvents(this, out cookie);
}
internal ReSharperUtil(IVim vim, IVimBufferCoordinatorFactory vimBufferCoordinatorFactory, SVsServiceProvider serviceProvider)
{
var vsShell = serviceProvider.GetService<SVsShell, IVsShell>();
_isResharperInstalled = vsShell.IsPackageInstalled(Resharper5Guid);
_vim = vim;
_vimBufferCoordinatorFactory = vimBufferCoordinatorFactory;
}
public VmsViewportAdornment(IWpfTextView view, SVsServiceProvider serviceProvider)
{
var service = (DTE)serviceProvider.GetService(typeof(DTE));
var properties = service.Properties["Visual Method Separators", "Global"];
var colorProperty = properties.Item("Color");
var color = UIntToColor(colorProperty.Value);
var dashStyleProperty = properties.Item("PenDashStyle");
var dashStyle = DashStyleFromInt(dashStyleProperty.Value);
var thicknessProperty = properties.Item("Thickness");
var thickness = (double) thicknessProperty.Value;
_view = view;
_view.LayoutChanged += OnLayoutChanged;
_layer = view.GetAdornmentLayer("VmsViewportAdornment");
_pen = new Pen(new SolidColorBrush(color), thickness)
{
DashStyle = dashStyle,
DashCap = PenLineCap.Flat,
};
_pen.Freeze();
}
internal VsVimHost(
IVsAdapter adapter,
ITextBufferFactoryService textBufferFactoryService,
ITextEditorFactoryService textEditorFactoryService,
ITextDocumentFactoryService textDocumentFactoryService,
ITextBufferUndoManagerProvider undoManagerProvider,
IVsEditorAdaptersFactoryService editorAdaptersFactoryService,
IEditorOperationsFactoryService editorOperationsFactoryService,
IWordUtilFactory wordUtilFactory,
ITextManager textManager,
ISharedServiceFactory sharedServiceFactory,
SVsServiceProvider serviceProvider)
: base(textBufferFactoryService, textEditorFactoryService, textDocumentFactoryService, editorOperationsFactoryService)
{
_vsAdapter = adapter;
_editorAdaptersFactoryService = editorAdaptersFactoryService;
_wordUtilFactory = wordUtilFactory;
_dte = (_DTE)serviceProvider.GetService(typeof(_DTE));
_vsExtensibility = (IVsExtensibility)serviceProvider.GetService(typeof(IVsExtensibility));
_textManager = textManager;
_sharedService = sharedServiceFactory.Create();
_vsMonitorSelection = serviceProvider.GetService<SVsShellMonitorSelection, IVsMonitorSelection>();
uint cookie;
_vsMonitorSelection.AdviseSelectionEvents(this, out cookie);
}
public GlobalUndoServiceFactory(
ITextUndoHistoryRegistry undoHistoryRegistry,
SVsServiceProvider serviceProvider,
Lazy<VisualStudioWorkspace> workspace)
{
_singleton = new GlobalUndoService(undoHistoryRegistry, serviceProvider, workspace);
}
internal static bool TryCreate(SVsServiceProvider vsServiceProvider, out IRoslynRenameUtil roslynRenameUtil)
{
RoslynRenameUtil util;
bool ret = TryCreateCore(vsServiceProvider, out util);
roslynRenameUtil = util;
return ret;
}
public JavaEditorConnectionListener(SVsServiceProvider serviceProvider)
{
ServiceProvider = serviceProvider;
RegisterSolutionEvents(serviceProvider);
Telemetry.Client.Get().TrackEvent("App.Start");
}
private void RegisterSolutionEvents(SVsServiceProvider serviceProvider)
{
var dte = serviceProvider.GetService(typeof(SApplicationObject)) as DTE2;
var solutionEvents = dte.Events.SolutionEvents;
solutionEvents.Opened += solutionEvents_Opened;
}
public TemplateCompletionHandlerProvider(
ITemplateEditorOptions options,
IVsEditorAdaptersFactoryService editorAdapterFactory,
SVsServiceProvider serviceProvider,
ICompletionBroker completionBroker)
{
if (options == null)
{
throw new ArgumentNullException(nameof(options));
}
if (editorAdapterFactory == null)
{
throw new ArgumentNullException(nameof(editorAdapterFactory));
}
if (serviceProvider == null)
{
throw new ArgumentNullException(nameof(serviceProvider));
}
if (completionBroker == null)
{
throw new ArgumentNullException(nameof(completionBroker));
}
this.options = options;
this.editorAdapterFactory = editorAdapterFactory;
this.serviceProvider = serviceProvider;
this.completionBroker = completionBroker;
}
public VisualStudioDiagnosticListTable(
SVsServiceProvider serviceProvider,
VisualStudioWorkspace workspace,
IDiagnosticService diagnosticService,
ExternalErrorDiagnosticUpdateSource errorSource,
ITableManagerProvider provider) :
this(serviceProvider, (Workspace)workspace, diagnosticService, errorSource, provider)
{
ConnectWorkspaceEvents();
_errorList = serviceProvider.GetService(typeof(SVsErrorList)) as IErrorList;
if (_errorList == null)
{
AddInitialTableSource(workspace.CurrentSolution, _liveTableSource);
return;
}
_errorList.PropertyChanged += OnErrorListPropertyChanged;
AddInitialTableSource(workspace.CurrentSolution, GetCurrentDataSource());
SuppressionStateColumnDefinition.SetDefaultFilter(_errorList.TableControl);
if (ErrorListHasFullSolutionAnalysisButton())
{
SetupErrorListFullSolutionAnalysis(workspace);
}
}
//=====================================================================
/// <summary>
/// Constructor
/// </summary>
/// <param name="serviceProvider">The service provider to use</param>
/// <param name="buffer">The buffer to use</param>
/// <param name="provider">The quick info source provider to use</param>
public XmlCommentsLinkQuickInfoSource(SVsServiceProvider serviceProvider, ITextBuffer buffer,
XmlCommentsLinkQuickInfoSourceProvider provider)
{
this.serviceProvider = serviceProvider;
this.textBuffer = buffer;
this.provider = provider;
}
internal PowerToolsUtil(SVsServiceProvider serviceProvider)
{
var vsShell = serviceProvider.GetService<SVsShell, IVsShell>();
_isQuickFindInstalled = vsShell.IsPackageInstalled(QuickFindGuid);
_searchModel = new Lazy<object>(GetSearchModel);
_isActivePropertyInfo = new Lazy<PropertyInfo>(GetIsActivePropertyInfo);
}
public HostFactory(
IVim vim,
ITextBufferFactoryService bufferFactoryService,
ITextEditorFactoryService editorFactoryService,
IEditorOptionsFactoryService editorOptionsFactoryService,
IKeyBindingService keyBindingService,
SVsServiceProvider serviceProvider,
IVsEditorAdaptersFactoryService adaptersFactory,
IResharperUtil resharperUtil,
IDisplayWindowBrokerFactoryService displayWindowBrokerFactoryService,
ITextManager textManager,
IVsAdapter adapter,
[EditorUtilsImport] IProtectedOperations protectedOperations,
IVimBufferCoordinatorFactory bufferCoordinatorFactory,
IKeyUtil keyUtil)
{
_vim = vim;
_keyBindingService = keyBindingService;
_bufferFactoryService = bufferFactoryService;
_editorFactoryService = editorFactoryService;
_editorOptionsFactoryService = editorOptionsFactoryService;
_resharperUtil = resharperUtil;
_displayWindowBrokerFactoryServcie = displayWindowBrokerFactoryService;
_adaptersFactory = adaptersFactory;
_textManager = textManager;
_adapter = adapter;
_protectedOperations = protectedOperations;
_bufferCoordinatorFactory = bufferCoordinatorFactory;
_keyUtil = keyUtil;
#if DEBUG
VimTrace.TraceSwitch.Level = TraceLevel.Info;
#endif
}
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();
}
public ClousotOptions(SVsServiceProvider serviceProvider) {
var shell = (IVsShell)serviceProvider.GetService(typeof(SVsShell));
IVsPackage package;
Marshal.ThrowExceptionForHR(shell.LoadPackage(GuidList.guidOptionsPagePackagePkg, out package));
this.page = ((OptionsPagePackage)package).GetOptionsPage();
}
/// <summary>
/// Default ctor
/// </summary>
protected XmlResourceCompletionSource(ITextBuffer textBuffer, SVsServiceProvider serviceProvider, IVsEditorAdaptersFactoryService vsEditorAdaptersFactoryService, IGlyphService glyphService)
{
this.textBuffer = textBuffer;
this.serviceProvider = serviceProvider;
this.vsEditorAdaptersFactoryService = vsEditorAdaptersFactoryService;
this.glyphService = glyphService;
}
public ClousotOptions(SVsServiceProvider serviceProvider) {
var shell = (IVsShell)serviceProvider.GetService(typeof(SVsShell));
IVsPackage package;
Marshal.ThrowExceptionForHR(shell.LoadPackage(Microsoft.Research.AskCodeContracts.Guids.guidOptionsPagePackagePkg, out package));
this.page = ((OptionsPagePackage)package).GetOptionsPage();
}
internal OptionsProviderFatory(IKeyBindingService keyBindingService, SVsServiceProvider provider, IVimApplicationSettings vimApplicationSettings, IVimProtectedOperations protectedOperations)
{
_keyBindingService = keyBindingService;
_serviceProvider = provider;
_vimApplicationSettings = vimApplicationSettings;
_protectedOperations = protectedOperations;
}
public TemplateProvider(SVsServiceProvider vsServiceProvider)
{
//var shellSettingsManager = new ShellSettingsManager(vsServiceProvider);
//writableSettingsStore = shellSettingsManager.GetWritableSettingsStore(SettingsScope.UserSettings);
//LoadTemplates();
}
public CommentTaskTokenSerializer(SVsServiceProvider serviceProvider)
{
var tokenInfo = serviceProvider.GetService(typeof(SVsTaskList)) as IVsCommentTaskInfo;
// The SVsTaskList may not be available (e.g. during "devenv /build")
_taskTokenList = tokenInfo != null ? GetTaskTokenList(tokenInfo) : string.Empty;
}
public Encouragements(SVsServiceProvider vsServiceProvider)
{
var shellSettingsManager = new ShellSettingsManager(vsServiceProvider);
writableSettingsStore = shellSettingsManager.GetWritableSettingsStore(SettingsScope.UserSettings);
LoadSettings();
}
private MiscellaneousDiagnosticListTable(
SVsServiceProvider serviceProvider, Workspace workspace, IDiagnosticService diagnosticService, ITableManagerProvider provider) :
base(serviceProvider, workspace, diagnosticService, provider)
{
_source = new LiveTableDataSource(serviceProvider, workspace, diagnosticService, IdentifierString);
AddInitialTableSource(workspace.CurrentSolution, _source);
}
internal DocumentMonitorService(SVsServiceProvider vsServiceProvider, ICompletionBroker completionBroker)
{
_vsServiceProvider = vsServiceProvider;
_runningDocumentTable = new RunningDocumentTable(vsServiceProvider);
_runningDocumentTable.Advise(this);
_completionBroker = completionBroker;
_dte = (DTE)vsServiceProvider.GetService(typeof(_DTE));
// NB: Resharper somehow f***s with this event, we need to do as
// little as possible in the event handler itself
var documentChanged = _changed
.ObserveOn(RxApp.TaskpoolScheduler)
.Throttle(TimeSpan.FromSeconds(2.0), RxApp.TaskpoolScheduler)
.Where(_ => !isCompletionActive())
.Select(_ => Unit.Default)
.ObserveOn(RxApp.MainThreadScheduler);
documentChanged.Subscribe(_ => SaveAll());
// NB: We use the message bus here, because we want to effectively
// merge all of the text change notifications from any document
MessageBus.Current.RegisterMessageSource(documentChanged, "AnyDocumentChanged");
checkAlreadyOpenDocuments(vsServiceProvider);
_dte.Events.WindowEvents.WindowActivated += (o,e) => _changed.OnNext(Unit.Default);
}
public SettingsFileUserNotifier(SVsServiceProvider sp, INotificationService notifier, SettingsPersister persister, SettingsLocator locator)
{
this.locator = locator;
this.notifier = notifier;
this.persister = persister;
dte = (DTE)sp.GetService(typeof(DTE));
}
public HostFactory(
IVim vim,
ITextBufferFactoryService bufferFactoryService,
ITextEditorFactoryService editorFactoryService,
IEditorOptionsFactoryService editorOptionsFactoryService,
IKeyBindingService keyBindingService,
SVsServiceProvider serviceProvider,
IVsEditorAdaptersFactoryService adaptersFactory,
IResharperUtil resharperUtil,
IDisplayWindowBrokerFactoryService displayWindowBrokerFactoryService,
IVsAdapter adapter,
IProtectedOperations protectedOperations,
IVimBufferCoordinatorFactory bufferCoordinatorFactory)
{
_vim = vim;
_keyBindingService = keyBindingService;
_bufferFactoryService = bufferFactoryService;
_editorFactoryService = editorFactoryService;
_editorOptionsFactoryService = editorOptionsFactoryService;
_resharperUtil = resharperUtil;
_displayWindowBrokerFactoryServcie = displayWindowBrokerFactoryService;
_adaptersFactory = adaptersFactory;
_adapter = adapter;
_protectedOperations = protectedOperations;
_bufferCoordinatorFactory = bufferCoordinatorFactory;
_vim.AutoLoadVimRc = false;
}
public ProjectExportProvider(SVsServiceProvider serviceProvider)
{
ServiceProvider = serviceProvider;
}
public RoslynBufferListener(SVsServiceProvider exportProvider, RoslynSetup forceImport)
{
ExportProvider = exportProvider;
}
public VSNotificationServiceFactory(SVsServiceProvider serviceProvider)
{
_uiShellService = (IVsUIShell)serviceProvider.GetService(typeof(SVsUIShell));
}
public static WritableSettingsStore GetWritableSettingsStore(this SVsServiceProvider vsServiceProvider)
{
var shellSettingsManager = new ShellSettingsManager(vsServiceProvider);
return(shellSettingsManager.GetWritableSettingsStore(SettingsScope.UserSettings));
}
public static VisualStudioVersion GetVisualStudioVersion(this SVsServiceProvider vsServiceProvider)
{
var dte = vsServiceProvider.GetService <SDTE, _DTE>();
return(dte.GetVisualStudioVersion());
}
public VisualStudioCodeDefinitionWindowService(SVsServiceProvider asyncServiceProvider, IThreadingContext threadingContext)
{
_asyncServiceProvider = (IAsyncServiceProvider)asyncServiceProvider;
_threadingContext = threadingContext;
}
protected VisualStudioBaseDiagnosticListTable(
SVsServiceProvider serviceProvider, Workspace workspace, IDiagnosticService diagnosticService, Guid identifier, ITableManagerProvider provider) :
base(workspace, provider, StandardTables.ErrorsTable, new TableDataSource(serviceProvider, workspace, diagnosticService, identifier))
{
}
public MiscellaneousDiagnosticListTable(
SVsServiceProvider serviceProvider, MiscellaneousFilesWorkspace workspace, IDiagnosticService diagnosticService, ITableManagerProvider provider) :
base(serviceProvider, workspace, diagnosticService, Identifier, provider)
{
AddTableSource();
}
public RemoteDiagnosticListTable(
SVsServiceProvider serviceProvider, RemoteLanguageServiceWorkspace workspace, IDiagnosticService diagnosticService, ITableManagerProvider provider) :
this(workspace, diagnosticService, provider)
{
ConnectWorkspaceEvents();
}
public OptionsSettings(SVsServiceProvider serviceProvider)
{
Requires.NotNull(serviceProvider, nameof(serviceProvider));
_serviceProvider = serviceProvider;
}
public AntlrLanguageInfo(SVsServiceProvider serviceProvider)
: base(serviceProvider, typeof(AntlrLanguageInfo).GUID)
{
}
protected abstract InteractiveEvaluator CreateInteractiveEvaluator(
SVsServiceProvider serviceProvider,
IViewClassifierAggregatorService classifierAggregator,
IContentTypeRegistryService contentTypeRegistry,
VisualStudioWorkspace workspace);
public PreviewPaneService(SVsServiceProvider serviceProvider)
{
_dte = serviceProvider.GetService(typeof(EnvDTE.DTE)) as EnvDTE.DTE;
}
internal StatusBarAdapter(IVim vim, IProtectedOperations vimProtectedOperations, ICommandMarginUtil commandMarginUtil, IVimApplicationSettings vimApplicationSettings, SVsServiceProvider vsServiceProvider)
{
_vim = vim;
_vimProtectedOperations = vimProtectedOperations;
_commandMarginUtil = commandMarginUtil;
_vimApplicationSettings = vimApplicationSettings;
_vsStatusbar = vsServiceProvider.GetService <SVsStatusbar, IVsStatusbar>();
_timer = new DispatcherTimer(
TimeSpan.FromSeconds(.1),
DispatcherPriority.Normal,
OnTimer,
Dispatcher.CurrentDispatcher)
{
IsEnabled = !_vimApplicationSettings.UseEditorCommandMargin
};
_vimApplicationSettings.SettingsChanged += OnSettingsChanged;
}
public StringTemplateLanguageInfo(SVsServiceProvider serviceProvider)
: base(serviceProvider, typeof(StringTemplateLanguageInfo).GUID)
{
}
public PreviewPaneService(IThreadingContext threadingContext, SVsServiceProvider serviceProvider)
: base(threadingContext)
{
_uiShell = serviceProvider.GetService(typeof(SVsUIShell)) as IVsUIShell;
}
public GotoDefnCommandFilter(IWpfTextView textView, SVsServiceProvider serviceProvider)
{
_serviceProvider = serviceProvider;
TextView = textView;
_project = new Lazy <Project>(() => new Project(() => TextView.TextBuffer.CurrentSnapshot.GetProject(GaugePackage.DTE)));
}
public SettingsLocator(SVsServiceProvider sp)
{
userFolder = new ShellSettingsManager(sp).GetApplicationDataFolder(ApplicationDataFolder.RoamingSettings);
}
public VisualStudioFileChangeTrackerFactoryFactory(ForegroundDispatcher foregroundDispatcher, SVsServiceProvider serviceProvider, JoinableTaskContext joinableTaskContext)
{
if (foregroundDispatcher == null)
{
throw new ArgumentNullException(nameof(foregroundDispatcher));
}
if (serviceProvider == null)
{
throw new ArgumentNullException(nameof(serviceProvider));
}
if (joinableTaskContext is null)
{
throw new ArgumentNullException(nameof(joinableTaskContext));
}
_foregroundDispatcher = foregroundDispatcher;
_joinableTaskContext = joinableTaskContext;
_fileChangeService = serviceProvider.GetService(typeof(SVsFileChangeEx)) as IVsAsyncFileChangeEx;
}
public SnippetCommandHandler(IThreadingContext threadingContext, IVsEditorAdaptersFactoryService editorAdaptersFactoryService, SVsServiceProvider serviceProvider)
: base(threadingContext, editorAdaptersFactoryService, serviceProvider)
{
}
public static DTE GetDte(SVsServiceProvider serviceProvider)
{
return((DTE)serviceProvider.GetService(typeof(DTE)));
}
public CSharpSnippetInfoService(
SVsServiceProvider serviceProvider,
[ImportMany] IEnumerable <Lazy <IAsynchronousOperationListener, FeatureMetadata> > asyncListeners)
: base(serviceProvider, Guids.CSharpLanguageServiceId, asyncListeners)
{
}
public VisualStudioSymbolNavigationServiceFactory(
SVsServiceProvider serviceProvider,
[Import] VisualStudio14StructureTaggerProvider outliningTaggerProvider)
{
_singleton = new VisualStudioSymbolNavigationService(serviceProvider, outliningTaggerProvider);
}
public static Project GetCurrentProject(ITextBuffer buffer, IVsEditorAdaptersFactoryService adaptersFactory, SVsServiceProvider serviceProvider)
{
IPersistFileFormat persistFileFormat = adaptersFactory.GetBufferAdapter(buffer) as IPersistFileFormat;
if (persistFileFormat == null)
{
return(null);
}
string ppzsFilename;
uint iii;
persistFileFormat.GetCurFile(out ppzsFilename, out iii);
if (String.IsNullOrWhiteSpace(ppzsFilename))
{
return(null);
}
DTE dte = GetDte(serviceProvider);
ProjectItem prjItem = dte.Solution.FindProjectItem(ppzsFilename);
if (prjItem == null)
{
return(null);
}
return(prjItem.ContainingProject);
}
/// <summary>
/// Default ctor
/// </summary>
public LayoutResourceCompletionSource(ITextBuffer textBuffer, SVsServiceProvider serviceProvider, IVsEditorAdaptersFactoryService vsEditorAdaptersFactoryService, IGlyphService glyphService)
: base(textBuffer, serviceProvider, vsEditorAdaptersFactoryService, glyphService)
{
}
public VisualStudioPersistentStorageLocationService([Import] SVsServiceProvider serviceProvider)
: base(assertIsForeground: false)
{
_serviceProvider = serviceProvider;
}
internal VimApplicationSettings(
SVsServiceProvider vsServiceProvider,
IVimProtectedOperations protectedOperations)
: this(vsServiceProvider.GetVisualStudioVersion(), vsServiceProvider.GetWritableSettingsStore(), protectedOperations)
{
}
public CSharpAddPackageCodeFixProvider([Import] SVsServiceProvider serviceProvider)
: base(new PackageInstaller(serviceProvider), ProjectMetadataProvider.Instance)
{
_serviceProvider = serviceProvider;
}
//=====================================================================
/// <summary>
/// Constructor
/// </summary>
/// <param name="textView">The text view to use</param>
/// <param name="serviceProvider">The service provider to use</param>
/// <param name="aggregator">The classifier tag aggregator to use</param>
/// <param name="navigator">The text structure navigator to use</param>
/// <param name="state">The Ctrl key state tracker to use</param>
/// <param name="enableInCRef">True to enable in <c>cref</c> targets, false if not</param>
public CSharpGoToDefinitionMouseProcessor(IWpfTextView textView, SVsServiceProvider serviceProvider,
IClassifier aggregator, ITextStructureNavigator navigator, CtrlKeyState state, bool enableInCRef) :
base(textView, serviceProvider, aggregator, navigator, state)
{
this.enableInCRef = enableInCRef;
}
public PreviewPaneService(SVsServiceProvider serviceProvider)
{
_serviceProvider = serviceProvider;
}
