/// <summary>
/// Rename document in the running document table from oldName to newName.
/// </summary>
/// <param name="provider">The service provider.</param>
/// <param name="oldName">Full path to the old name of the document.</param>
/// <param name="newName">Full path to the new name of the document.</param>
/// <param name="newItemId">The new item id of the document</param>
public static void RenameDocument(IServiceProvider site, string oldName, string newName, uint newItemId)
{
if(site == null)
{
throw new ArgumentNullException("site");
}
if(String.IsNullOrEmpty(oldName))
{
throw new ArgumentException(SR.GetString(SR.ParameterCannotBeNullOrEmpty, CultureInfo.CurrentUICulture), "oldName");
}
if(String.IsNullOrEmpty(newName))
{
throw new ArgumentException(SR.GetString(SR.ParameterCannotBeNullOrEmpty, CultureInfo.CurrentUICulture), "newName");
}
if(newItemId == VSConstants.VSITEMID_NIL)
{
throw new ArgumentNullException("newItemId");
}
IVsRunningDocumentTable pRDT = site.GetService(typeof(SVsRunningDocumentTable)) as IVsRunningDocumentTable;
IVsUIShellOpenDocument doc = site.GetService(typeof(SVsUIShellOpenDocument)) as IVsUIShellOpenDocument;
if(pRDT == null || doc == null) return;
IVsHierarchy pIVsHierarchy;
uint itemId;
IntPtr docData;
uint uiVsDocCookie;
ErrorHandler.ThrowOnFailure(pRDT.FindAndLockDocument((uint)_VSRDTFLAGS.RDT_NoLock, oldName, out pIVsHierarchy, out itemId, out docData, out uiVsDocCookie));
if(docData != IntPtr.Zero)
{
try
{
IntPtr pUnk = Marshal.GetIUnknownForObject(pIVsHierarchy);
Guid iid = typeof(IVsHierarchy).GUID;
IntPtr pHier;
Marshal.QueryInterface(pUnk, ref iid, out pHier);
try
{
ErrorHandler.ThrowOnFailure(pRDT.RenameDocument(oldName, newName, pHier, newItemId));
}
finally
{
if(pHier != IntPtr.Zero)
Marshal.Release(pHier);
if(pUnk != IntPtr.Zero)
Marshal.Release(pUnk);
}
}
finally
{
Marshal.Release(docData);
}
}
}
public TextViewFilter(IServiceProvider serviceProvider, IVsTextView vsTextView) {
var compModel = (IComponentModel)serviceProvider.GetService(typeof(SComponentModel));
_vsEditorAdaptersFactoryService = compModel.GetService<IVsEditorAdaptersFactoryService>();
_debugger = (IVsDebugger)serviceProvider.GetService(typeof(IVsDebugger));
vsTextView.GetBuffer(out _vsTextLines);
_wpfTextView = _vsEditorAdaptersFactoryService.GetWpfTextView(vsTextView);
ErrorHandler.ThrowOnFailure(vsTextView.AddCommandFilter(this, out _next));
}
public TextInformationManager(IServiceProvider serviceProvider, IComponentModel componentModel)
{
this.serviceProvider = serviceProvider;
this.componentModel = componentModel;
fontAndColorStorage = (IVsFontAndColorStorage) serviceProvider.GetService(typeof (SVsFontAndColorStorage));
fontAndColorUtilities = fontAndColorStorage as IVsFontAndColorUtilities;
fontAndColorCache = (IVsFontAndColorCacheManager)serviceProvider.GetService(typeof(SVsFontAndColorCacheManager));
textManager = (IVsTextManager) serviceProvider.GetService(typeof (SVsTextManager));
editorAdaptersFactoryService = componentModel.GetService<IVsEditorAdaptersFactoryService>();
textStructureNavigatorSelectorService = componentModel.GetService<ITextStructureNavigatorSelectorService>();
classicationFormatMapService = componentModel.GetService<IClassificationFormatMapService>();
classificationAggregatorService = componentModel.GetService<IClassifierAggregatorService>();
}
internal TextManager(
IVsAdapter adapter,
ITextDocumentFactoryService textDocumentFactoryService,
ITextBufferFactoryService textBufferFactoryService,
ISharedService sharedService,
SVsServiceProvider serviceProvider)
{
_vsAdapter = adapter;
_serviceProvider = serviceProvider;
_textManager = _serviceProvider.GetService<SVsTextManager, IVsTextManager>();
_textDocumentFactoryService = textDocumentFactoryService;
_textBufferFactoryService = textBufferFactoryService;
_runningDocumentTable = _serviceProvider.GetService<SVsRunningDocumentTable, IVsRunningDocumentTable>();
_sharedService = sharedService;
}
public IdleManager(IServiceProvider serviceProvider)
{
_serviceProvider = serviceProvider;
_compMgr = new Lazy <IOleComponentManager>(() =>
(IOleComponentManager)serviceProvider?.GetService(typeof(SOleComponentManager))
);
_compId = new Lazy <uint>(() => {
var compMgr = _compMgr.Value;
if (compMgr == null)
{
return(VSConstants.VSCOOKIE_NIL);
}
uint compId;
OLECRINFO[] crInfo = new OLECRINFO[1];
crInfo[0].cbSize = (uint)Marshal.SizeOf(typeof(OLECRINFO));
crInfo[0].grfcrf = (uint)_OLECRF.olecrfNeedIdleTime;
crInfo[0].grfcadvf = (uint)0;
crInfo[0].uIdleTimeInterval = 0;
if (ErrorHandler.Failed(compMgr.FRegisterComponent(this, crInfo, out compId)))
{
return(VSConstants.VSCOOKIE_NIL);
}
return(compId);
});
}
/// <summary>
/// Use this instead of VsShellUtilities.ShowMessageBox because VSU uses ThreadHelper which
/// uses a private interface that can't be mocked AND goes to the global service provider.
/// </summary>
public static int ShowMessageBox(IServiceProvider serviceProvider, string message, string title, OLEMSGICON icon, OLEMSGBUTTON msgButton, OLEMSGDEFBUTTON defaultButton) {
IVsUIShell uiShell = serviceProvider.GetService(typeof(IVsUIShell)) as IVsUIShell;
Debug.Assert(uiShell != null, "Could not get the IVsUIShell object from the services exposed by this serviceprovider");
if (uiShell == null) {
throw new InvalidOperationException();
}
Guid emptyGuid = Guid.Empty;
int result = 0;
serviceProvider.GetUIThread().Invoke(() => {
ErrorHandler.ThrowOnFailure(uiShell.ShowMessageBox(
0,
ref emptyGuid,
title,
message,
null,
0,
msgButton,
defaultButton,
icon,
0,
out result));
});
return result;
}
/// <include file='doc\VsShellUtilities.uex' path='docs/doc[@for="VsShellUtilities.EmptyTaskList"]/*' />
/// <devdoc>
/// Empty the task list.
/// </devdoc>
/// <param name="serviceProvider">The service provider.</param>
/// <returns>If the method succeeds, it returns S_OK. If it fails, it returns an error code. </returns>
public static int EmptyTaskList(IServiceProvider serviceProvider)
{
if (serviceProvider == null)
{
throw new ArgumentException("serviceProvider");
}
IVsTaskList taskList = serviceProvider.GetService(typeof(IVsTaskList)) as IVsTaskList;
if (taskList == null)
{
throw new InvalidOperationException();
}
IVsEnumTaskItems enumTaskItems;
int result = VSConstants.S_OK;
try
{
ErrorHandler.ThrowOnFailure(taskList.EnumTaskItems(out enumTaskItems));
if (enumTaskItems == null)
{
throw new InvalidOperationException();
}
// Retrieve the task item text and check whether it is equal with one that supposed to be thrown.
uint[] fetched = new uint[1];
do
{
IVsTaskItem[] taskItems = new IVsTaskItem[1];
result = enumTaskItems.Next(1, taskItems, fetched);
if (fetched[0] == 1)
{
IVsTaskItem2 taskItem = taskItems[0] as IVsTaskItem2;
if (taskItem != null)
{
int canDelete;
ErrorHandler.ThrowOnFailure(taskItem.CanDelete(out canDelete));
if (canDelete == 1)
{
ErrorHandler.ThrowOnFailure(taskItem.OnDeleteTask());
}
}
}
} while (result == VSConstants.S_OK && fetched[0] == 1);
}
catch (COMException e)
{
Trace.WriteLine("Exception : " + e.Message);
result = e.ErrorCode;
}
return result;
}
internal TextManager(
IVsAdapter adapter,
SVsServiceProvider serviceProvider)
{
_adapter = adapter;
_serviceProvider = serviceProvider;
_textManager = _serviceProvider.GetService<SVsTextManager, IVsTextManager>();
_table = new RunningDocumentTable(_serviceProvider);
}
protected AbstractObjectBrowserLibraryManager(string languageName, Guid libraryGuid, IServiceProvider serviceProvider)
: base(libraryGuid, serviceProvider)
{
_languageName = languageName;
var componentModel = (IComponentModel)serviceProvider.GetService(typeof(SComponentModel));
this.Workspace = componentModel.GetService<VisualStudioWorkspace>();
this.Workspace.WorkspaceChanged += OnWorkspaceChanged;
}
/// <summary>
/// Look in the registry under the current hive for the path
/// of MSBuild
/// </summary>
/// <returns></returns>
/// <summary>
/// Is Visual Studio in design mode.
/// </summary>
/// <param name="serviceProvider">The service provider.</param>
/// <returns>true if visual studio is in design mode</returns>
public static bool IsVisualStudioInDesignMode(IServiceProvider site) {
Utilities.ArgumentNotNull("site", site);
IVsMonitorSelection selectionMonitor = site.GetService(typeof(IVsMonitorSelection)) as IVsMonitorSelection;
uint cookie = 0;
int active = 0;
Guid designContext = VSConstants.UICONTEXT_DesignMode;
ErrorHandler.ThrowOnFailure(selectionMonitor.GetCmdUIContextCookie(ref designContext, out cookie));
ErrorHandler.ThrowOnFailure(selectionMonitor.IsCmdUIContextActive(cookie, out active));
return active != 0;
}
protected AbstractObjectBrowserLibraryManager(string languageName, Guid libraryGuid, __SymbolToolLanguage preferredLanguage, IServiceProvider serviceProvider)
: base(libraryGuid, serviceProvider)
{
_languageName = languageName;
_preferredLanguage = preferredLanguage;
var componentModel = (IComponentModel)serviceProvider.GetService(typeof(SComponentModel));
this.Workspace = componentModel.GetService<VisualStudioWorkspace>();
this.LibraryService = this.Workspace.Services.GetLanguageServices(languageName).GetService<ILibraryService>();
this.Workspace.WorkspaceChanged += OnWorkspaceChanged;
}
protected SolutionListener(IServiceProvider serviceProvider)
{
this.serviceProvider = serviceProvider;
this.solution = serviceProvider.GetService(typeof(SVsSolution)) as IVsSolution;
Debug.Assert(this.solution != null, "Could not get the IVsSolution object from the services exposed by this project");
if (this.solution == null)
{
throw new InvalidOperationException();
}
}
/// <include file='doc\VsShellUtilities.uex' path='docs/doc[@for="Utilities.IsInAutomationFunction"]/*' />
/// <devdoc>
/// Is an extensibility object executing an automation function.
/// </devdoc>
/// <param name="serviceProvider">The service provider.</param>
/// <returns>true if the extensiblity object is executing an automation function.</returns>
public static bool IsInAutomationFunction(IServiceProvider serviceProvider) {
Utilities.ArgumentNotNull("serviceProvider", serviceProvider);
IVsExtensibility3 extensibility = serviceProvider.GetService(typeof(EnvDTE.IVsExtensibility)) as IVsExtensibility3;
if (extensibility == null) {
throw new InvalidOperationException();
}
int inAutomation = 0;
ErrorHandler.ThrowOnFailure(extensibility.IsInAutomationFunction(out inAutomation));
return inAutomation != 0;
}
public GoToDefinitionFilterProvider([Import(typeof(SVsServiceProvider))] System.IServiceProvider serviceProvider)
{
this.serviceProvider = serviceProvider;
var dte = serviceProvider.GetService(typeof(SDTE)) as DTE;
var events = dte.Events as Events2;
if (events != null)
{
this.solutionEvents = events.SolutionEvents;
this.solutionEvents.AfterClosing += Cleanup;
}
}
public IDisposable SubscribeForumCommandStatusChanged(
IServiceProvider provider, Action handler)
{
var activeForumSvc = provider.GetService<IActiveForumService>();
if (activeForumSvc != null)
{
CodeJam.Extensibility.EventHandler<IActiveForumService> statusUpdater = sender => handler();
activeForumSvc.ActiveForumChanged += statusUpdater;
return Disposable.Create(
() => activeForumSvc.ActiveForumChanged -= statusUpdater);
}
return Disposable.Empty;
}
internal TextManager(
IVsAdapter adapter,
ITextDocumentFactoryService textDocumentFactoryService,
ITextBufferFactoryService textBufferFactoryService,
SVsServiceProvider serviceProvider)
{
_vsAdapter = adapter;
_serviceProvider = serviceProvider;
_textManager = _serviceProvider.GetService<SVsTextManager, IVsTextManager>();
_textDocumentFactoryService = textDocumentFactoryService;
_textBufferFactoryService = textBufferFactoryService;
_table = new RunningDocumentTable(_serviceProvider);
}
public override object EditValue(System.ComponentModel.ITypeDescriptorContext context, System.IServiceProvider provider, object value)
{
var edSvc = (System.Windows.Forms.Design.IWindowsFormsEditorService)provider.GetService(typeof(System.Windows.Forms.Design.IWindowsFormsEditorService));
var popupUI = new CopyrightForm();
popupUI.Copyright = (string)value;
if (edSvc.ShowDialog(popupUI) == System.Windows.Forms.DialogResult.OK)
{
value = popupUI.Copyright;
context.OnComponentChanged();
}
return(value);
}
public override object EditValue(System.ComponentModel.ITypeDescriptorContext context, System.IServiceProvider provider, object value)
{
IWindowsFormsEditorService edSvc = (IWindowsFormsEditorService)provider.GetService(typeof(IWindowsFormsEditorService));
if (edSvc != null)
{
SortingEditorControl edtorControl = new SortingEditorControl(edSvc, value);
edSvc.DropDownControl(edtorControl);
return(edtorControl.Result);
}
return(value);
}
internal CommandExecutionWatcher(IServiceProvider serviceProvider)
{
Validate.IsNotNull(serviceProvider, "serviceProvider");
this.serviceProvider = serviceProvider;
var rpct = (IVsRegisterPriorityCommandTarget)this.serviceProvider.GetService(typeof(SVsRegisterPriorityCommandTarget));
if (rpct != null)
{
// We can ignore the return code here as there really isn't anything reasonable we could do to deal with failure,
// and it is essentially a no-fail method.
rpct.RegisterPriorityCommandTarget(dwReserved: 0U, pCmdTrgt: this, pdwCookie: out this.priorityCommandTargetCookie);
}
this.macroRecorder = (IRecorderPrivate)serviceProvider.GetService(typeof(IRecorder));
}
/// <summary>
/// Search the registry fir the tool path for MSBuild.
/// </summary>
public static string GetMsBuildPath(IServiceProvider serviceProvider, string msbuildVersion)
{
string registryPath;
if (serviceProvider == null)
{
return(String.Empty);
}
ILocalRegistry3 localRegistry = serviceProvider.GetService(typeof(SLocalRegistry)) as ILocalRegistry3;
if (localRegistry == null)
{
return(String.Empty);
}
// first, we need the registry hive currently in use
ErrorHandler.ThrowOnFailure(localRegistry.GetLocalRegistryRoot(out registryPath));
// now that we have it, append the subkey we are interested in to it
if (!registryPath.EndsWith("\\"))
{
registryPath += '\\';
}
registryPath += "MSBuild";
// finally, get the value from the registry
string msBuildPath = null;
using (Microsoft.Win32.RegistryKey vsKey = Microsoft.Win32.Registry.LocalMachine.OpenSubKey(registryPath, false))
{
msBuildPath = (string)vsKey.GetValue("MSBuildBinPath", null);
}
if (!string.IsNullOrEmpty(msBuildPath))
{
return(msBuildPath);
}
// The path to MSBuild was not found in the VisualStudio's registry hive, so try to
// find it in the new MSBuild hive.
registryPath = string.Format(CultureInfo.InvariantCulture, "Software\\Microsoft\\MSBuild\\ToolsVersions\\{0}", msbuildVersion);
using (Microsoft.Win32.RegistryKey msbuildKey = Microsoft.Win32.Registry.LocalMachine.OpenSubKey(registryPath, false))
{
msBuildPath = (string)msbuildKey.GetValue("MSBuildToolsPath", null);
}
if (string.IsNullOrEmpty(msBuildPath))
{
string error = SR.GetString(SR.ErrorMsBuildRegistration);
throw new FileLoadException(error);
}
return(msBuildPath);
}
public override object EditValue(System.ComponentModel.ITypeDescriptorContext context, System.IServiceProvider provider, object value)
{
var edSvc = (System.Windows.Forms.Design.IWindowsFormsEditorService)provider.GetService(typeof(System.Windows.Forms.Design.IWindowsFormsEditorService));
var entity = (context.Instance as EntityShape).ModelElement as Entity;
var popupUI = new SecurityFunctionForm();
popupUI.Entity = entity;
if (edSvc.ShowDialog(popupUI) == System.Windows.Forms.DialogResult.OK)
{
context.OnComponentChanged();
}
return(value);
}
// Displays the UI for value selection.
public override object EditValue(System.ComponentModel.ITypeDescriptorContext context, System.IServiceProvider provider, object value)
{
IWindowsFormsEditorService edSvc = (IWindowsFormsEditorService)provider.GetService(typeof(IWindowsFormsEditorService));
if (edSvc != null)
{
//DateTimeFormatControl supsubControl = new DateTimeFormatControl(edSvc, value);
//edSvc.DropDownControl(supsubControl);
ItemInputForm frm = new ItemInputForm(false, value);
edSvc.ShowDialog(frm);
return(frm.Value);
}
return(value);
}
private IEnumerable <ITextBuffer> GetDocumentTextBuffers(DocumentLoad documentLoad)
{
var list = new List <ITextBuffer>();
foreach (var docCookie in _runningDocumentTable.GetRunningDocumentCookies())
{
if (documentLoad == DocumentLoad.RespectLazy && isLazyLoaded(docCookie))
{
continue;
}
if (_vsAdapter.GetTextBufferForDocCookie(docCookie).TryGetValue(out ITextBuffer buffer))
{
list.Add(buffer);
}
}
return(list);
bool isLazyLoaded(uint documentCookie)
{
try
{
if (_runningDocumentTable4 is null)
{
_runningDocumentTable4 = _serviceProvider.GetService <SVsRunningDocumentTable, IVsRunningDocumentTable4>();
}
var flags = (_VSRDTFLAGS4)_runningDocumentTable4.GetDocumentFlags(documentCookie);
return(0 != (flags & _VSRDTFLAGS4.RDT_PendingInitialization));
}
catch (Exception)
{
return(false);
}
}
}
public int DebugLaunch(uint flags)
{
VsDebugTargetInfo2[] targets;
int hr = QueryDebugTargets(out targets);
if (ErrorHandler.Failed(hr))
{
return(hr);
}
flags |= (uint)__VSDBGLAUNCHFLAGS140.DBGLAUNCH_ContainsStartupTask;
VsDebugTargetInfo4[] appPackageDebugTarget = new VsDebugTargetInfo4[1];
int targetLength = (int)Marshal.SizeOf(typeof(VsDebugTargetInfo4));
appPackageDebugTarget[0].AppPackageLaunchInfo.AppUserModelID = DeployAppUserModelID;
appPackageDebugTarget[0].AppPackageLaunchInfo.PackageMoniker = DeployPackageMoniker;
appPackageDebugTarget[0].dlo = (uint)_DEBUG_LAUNCH_OPERATION4.DLO_AppPackageDebug;
appPackageDebugTarget[0].LaunchFlags = flags;
appPackageDebugTarget[0].bstrRemoteMachine = targets[0].bstrRemoteMachine;
appPackageDebugTarget[0].bstrExe = targets[0].bstrExe;
appPackageDebugTarget[0].bstrArg = targets[0].bstrArg;
appPackageDebugTarget[0].bstrCurDir = targets[0].bstrCurDir;
appPackageDebugTarget[0].bstrEnv = targets[0].bstrEnv;
appPackageDebugTarget[0].dwProcessId = targets[0].dwProcessId;
appPackageDebugTarget[0].pStartupInfo = IntPtr.Zero; //?
appPackageDebugTarget[0].guidLaunchDebugEngine = targets[0].guidLaunchDebugEngine;
appPackageDebugTarget[0].dwDebugEngineCount = targets[0].dwDebugEngineCount;
appPackageDebugTarget[0].pDebugEngines = targets[0].pDebugEngines;
appPackageDebugTarget[0].guidPortSupplier = targets[0].guidPortSupplier;
appPackageDebugTarget[0].bstrPortName = targets[0].bstrPortName;
appPackageDebugTarget[0].bstrOptions = targets[0].bstrOptions;
appPackageDebugTarget[0].fSendToOutputWindow = targets[0].fSendToOutputWindow;
appPackageDebugTarget[0].pUnknown = targets[0].pUnknown;
appPackageDebugTarget[0].guidProcessLanguage = targets[0].guidProcessLanguage;
appPackageDebugTarget[0].project = this.project;
// Pass the debug launch targets to the debugger
System.IServiceProvider sp = this.project as System.IServiceProvider;
IVsDebugger4 debugger4 = (IVsDebugger4)sp.GetService(typeof(SVsShellDebugger));
VsDebugTargetProcessInfo[] results = new VsDebugTargetProcessInfo[1];
debugger4.LaunchDebugTargets4(1, appPackageDebugTarget, results);
return(VSConstants.S_OK);
}
/// <include file='doc\ExpansionProvider.uex' path='docs/doc[@for="ExpansionProvider.DisplayExpansionBrowser"]/*' />
public virtual bool DisplayExpansionBrowser(IVsTextView view, string prompt, string[] types, bool includeNullType, string[] kinds, bool includeNullKind)
{
if (this.expansionActive)
{
this.EndTemplateEditing(true);
}
if (this.source.IsCompletorActive)
{
this.source.DismissCompletor();
}
this.view = view;
IServiceProvider site = this.source.LanguageService.Site;
IVsTextManager2 textmgr = site.GetService(typeof(SVsTextManager)) as IVsTextManager2;
if (textmgr == null)
{
return(false);
}
IVsExpansionManager exmgr;
textmgr.GetExpansionManager(out exmgr);
Guid languageSID = this.source.LanguageService.GetLanguageServiceGuid();
int hr = 0;
if (exmgr != null)
{
hr = exmgr.InvokeInsertionUI(view, // pView
this, // pClient
languageSID, // guidLang
types, // bstrTypes
(types == null) ? 0 : types.Length, // iCountTypes
includeNullType ? 1 : 0, // fIncludeNULLType
kinds, // bstrKinds
(kinds == null) ? 0 : kinds.Length, // iCountKinds
includeNullKind ? 1 : 0, // fIncludeNULLKind
prompt, // bstrPrefixText
">" //bstrCompletionChar
);
if (NativeMethods.Succeeded(hr))
{
return(true);
}
}
return(false);
}
public override object EditValue(ITypeDescriptorContext context, System.IServiceProvider provider, object value)
{
IWindowsFormsEditorService svc = provider.GetService(typeof(IWindowsFormsEditorService)) as IWindowsFormsEditorService;
Dictionary <string, object> v = value as Dictionary <string, object>;
if (svc != null && v != null)
{
using (FrmObjEditor form = new FrmObjEditor(v))
{
form.ShowDialog();
v = form.Value.Prop;
}
}
return(v); // can also replace the wrapper object here
}
public FileChangeManager(IServiceProvider serviceProvider)
{
if (serviceProvider == null)
{
throw new ArgumentNullException("serviceProvider");
}
this.fileChangeService = (IVsFileChangeEx)serviceProvider.GetService(typeof(SVsFileChangeEx));
if (this.fileChangeService == null)
{
// VS is in bad state, since the SVsFileChangeEx could not be proffered.
throw new InvalidOperationException();
}
}
internal CommandExecutionWatcher(IServiceProvider serviceProvider)
{
Validate.IsNotNull(serviceProvider, "serviceProvider");
this.serviceProvider = serviceProvider;
var rpct = (IVsRegisterPriorityCommandTarget)this.serviceProvider.GetService(typeof(SVsRegisterPriorityCommandTarget));
if (rpct != null)
{
// We can ignore the return code here as there really isn't anything reasonable we could do to deal with failure,
// and it is essentially a no-fail method.
rpct.RegisterPriorityCommandTarget(dwReserved: 0U, pCmdTrgt: this, pdwCookie: out this.priorityCommandTargetCookie);
}
this.macroRecorder = (IRecorderPrivate)serviceProvider.GetService(typeof(IRecorder));
}
internal static CommonProjectNode GetStartupProject(System.IServiceProvider serviceProvider)
{
if (serviceProvider == null)
{
Debug.Assert(false, "No service provider");
return(null);
}
var buildMgr = (IVsSolutionBuildManager)serviceProvider.GetService(typeof(IVsSolutionBuildManager));
if (buildMgr != null && ErrorHandler.Succeeded(buildMgr.get_StartupProject(out var hierarchy)) && hierarchy != null)
{
return(hierarchy.GetProject().GetCommonProject());
}
return(null);
}
/// <summary>
/// Create a new XML model provider.
/// </summary>
public VSXmlModelProvider(IServiceProvider services, IXmlDesignerPackage xmlDesignerPackage)
{
Debug.Assert(services != null);
Debug.Assert(xmlDesignerPackage != null);
_xmlDesignerPackage = xmlDesignerPackage;
_services = services;
if (_xmlStore == null)
{
var xmlEditorService = (XmlEditorService)services.GetService(
typeof(XmlEditorService));
_xmlStore = xmlEditorService.CreateXmlStore();
_xmlStore.EditingScopeCompleted += OnXmlModelTransactionCompleted;
_xmlStore.UndoRedoCompleted += OnXmlModelUndoRedoCompleted;
}
}
/// <summary>
/// Invoke the property page help in response to an end-user request.
/// </summary>
/// <param name="pszHelpDir"></param>
public void Help(string pszHelpDir)
{
System.IServiceProvider iPropertyPageSite =
this.PropertyPageSite as System.IServiceProvider;
if (iPropertyPageSite != null)
{
Microsoft.VisualStudio.VSHelp.Help service = iPropertyPageSite.GetService(
typeof(Microsoft.VisualStudio.VSHelp.Help)) as Microsoft.VisualStudio.VSHelp.Help;
if (service != null)
{
service.DisplayTopicFromF1Keyword(this.HelpKeyword);
}
}
}
/// <summary>
/// Create a new XML model provider.
/// </summary>
public VSXmlModelProvider(IServiceProvider services, IXmlDesignerPackage xmlDesignerPackage)
{
Debug.Assert(services != null);
Debug.Assert(xmlDesignerPackage != null);
_xmlDesignerPackage = xmlDesignerPackage;
_services = services;
if (_xmlStore == null)
{
var xmlEditorService = (XmlEditorService)services.GetService(
typeof(XmlEditorService));
_xmlStore = xmlEditorService.CreateXmlStore();
_xmlStore.EditingScopeCompleted += OnXmlModelTransactionCompleted;
_xmlStore.UndoRedoCompleted += OnXmlModelUndoRedoCompleted;
}
}
public override object EditValue(System.ComponentModel.ITypeDescriptorContext context, System.IServiceProvider provider, object value)
{
IWindowsFormsEditorService edSvc = (IWindowsFormsEditorService)provider.GetService(typeof(IWindowsFormsEditorService));
if (edSvc != null)
{
// 可以打开任何特定的对话框
OpenFileDialog dialog = new OpenFileDialog();
if (dialog.ShowDialog().Equals(DialogResult.OK))
{
return(dialog.FileName);
}
}
return(value);
}
public override object EditValue(System.ComponentModel.ITypeDescriptorContext context, System.IServiceProvider provider, object value)
{
IWindowsFormsEditorService edSvc = (IWindowsFormsEditorService)provider.GetService(typeof(IWindowsFormsEditorService));
if (edSvc != null)
{
RepCustomXRRichText.RichTextEditorForm frm = new RepCustomXRRichText.RichTextEditorForm();
frm.richTextBox1.Rtf = (context.Instance as XRRichText).Rtf;
edSvc.ShowDialog(frm);
return(frm.richTextBox1.Rtf);
}
return(value);
}
public override object EditValue(ITypeDescriptorContext context, System.IServiceProvider provider, object value)
{
IWindowsFormsEditorService IFService = provider.GetService(typeof(IWindowsFormsEditorService)) as IWindowsFormsEditorService;
Color4?color = value as Color4?;
if (IFService != null)
{
using (ColorDialog form = new ColorDialog())
{
form.ShowDialog();
color = form.Color;
}
}
return(color);
}
/// <summary>
/// Sets the help context into the help service for this property page.
/// </summary>
private void SetHelpContext()
{
if (this.pageSite != null)
{
System.IServiceProvider sp = this.pageSite as System.IServiceProvider;
if (sp != null)
{
IHelpService helpService = sp.GetService(typeof(IHelpService)) as IHelpService;
if (helpService != null)
{
helpService.AddContextAttribute("Keyword", String.Empty, HelpKeywordType.F1Keyword);
}
}
}
}
/// <include file='doc\VsShellUtilities.uex' path='docs/doc[@for="Utilities.IsInAutomationFunction"]/*' />
/// <devdoc>
/// Is an extensibility object executing an automation function.
/// </devdoc>
/// <param name="serviceProvider">The service provider.</param>
/// <returns>true if the extensibility object is executing an automation function.</returns>
public static bool IsInAutomationFunction(IServiceProvider serviceProvider)
{
Utilities.ArgumentNotNull("serviceProvider", serviceProvider);
IVsExtensibility3 extensibility = serviceProvider.GetService(typeof(EnvDTE.IVsExtensibility)) as IVsExtensibility3;
if (extensibility == null)
{
throw new InvalidOperationException();
}
int inAutomation = 0;
ErrorHandler.ThrowOnFailure(extensibility.IsInAutomationFunction(out inAutomation));
return(inAutomation != 0);
}
internal static void OpenVsWebBrowser(System.IServiceProvider serviceProvider, string url)
{
serviceProvider.GetUIThread().Invoke(() => {
var web = serviceProvider.GetService(typeof(SVsWebBrowsingService)) as IVsWebBrowsingService;
if (web == null)
{
OpenWebBrowser(url);
return;
}
IVsWindowFrame frame;
ErrorHandler.ThrowOnFailure(web.Navigate(url, (uint)__VSWBNAVIGATEFLAGS.VSNWB_ForceNew, out frame));
frame.Show();
});
}
public override object EditValue(System.ComponentModel.ITypeDescriptorContext context,
System.IServiceProvider provider, object value)
{
IWindowsFormsEditorService edSvc =
(IWindowsFormsEditorService)provider.GetService(typeof(IWindowsFormsEditorService));
if (edSvc != null)
{
VehicleTypeControl vehicleTypeControl = new VehicleTypeControl((TypeOfVehicle)value);
vehicleTypeControl.Size = vehicleTypeControl.Image.Size;
edSvc.DropDownControl(vehicleTypeControl);
return(vehicleTypeControl.CurrentType);
}
return(value);
}
public static string GetVsMainVersion(IServiceProvider serviceProvider)
{
const string defaultMainVersion = "15.0";
try
{
var dte = (DTE)serviceProvider.GetService(typeof(DTE));
return(dte?.Version ?? defaultMainVersion);
}
catch (Exception ex)
{
Debug.WriteLine(ex);
return(defaultMainVersion);
}
}
/// <summary>
/// Opens the find symbols dialog with a list of results. This is done by requesting
/// that VS does a search against our library GUID. Our library then responds to
/// that request by extracting the prvoided symbol list out and using that for the
/// search results.
/// </summary>
private void ShowFindSymbolsDialog(string expr, IVsNavInfo symbols)
{
// ensure our library is loaded so find all references will go to our library
_serviceProvider.GetService(typeof(IPythonLibraryManager));
if (!string.IsNullOrEmpty(expr))
{
var findSym = (IVsFindSymbol)_serviceProvider.GetService(typeof(SVsObjectSearch));
VSOBSEARCHCRITERIA2 searchCriteria = new VSOBSEARCHCRITERIA2();
searchCriteria.eSrchType = VSOBSEARCHTYPE.SO_ENTIREWORD;
searchCriteria.pIVsNavInfo = symbols;
searchCriteria.grfOptions = (uint)_VSOBSEARCHOPTIONS2.VSOBSO_LISTREFERENCES;
searchCriteria.szName = expr;
Guid guid = Guid.Empty;
// new Guid("{a5a527ea-cf0a-4abf-b501-eafe6b3ba5c6}")
ErrorHandler.ThrowOnFailure(findSym.DoSearch(new Guid(CommonConstants.LibraryGuid), new VSOBSEARCHCRITERIA2[] { searchCriteria }));
}
else
{
var statusBar = (IVsStatusbar)_serviceProvider.GetService(typeof(SVsStatusbar));
statusBar.SetText("The caret must be on valid expression to find all references.");
}
}
public override object EditValue(ITypeDescriptorContext context, System.IServiceProvider provider, object value)
{
FormTextInput form = new FormTextInput();
form.tbxText.Text = value as string;
IWindowsFormsEditorService svc = provider.GetService(typeof(IWindowsFormsEditorService)) as IWindowsFormsEditorService;
if (svc.ShowDialog(form) == DialogResult.OK)
{
value = form.tbxText.Text;
}
return(value);
}
public override object EditValue(System.ComponentModel.ITypeDescriptorContext context, System.IServiceProvider provider, object value)
{
IWindowsFormsEditorService edSvc = (IWindowsFormsEditorService)provider.GetService(typeof(IWindowsFormsEditorService));
if (edSvc != null)
{
SelTableForm frm = new SelTableForm();
if (frm.ShowDialog() == DialogResult.OK)
{
return(frm.m_SelTable.Code);
}
}
return(value);
}
///--------------------------------------------------------------------------------------------
/// <summary>
/// Initialize and listen to debug mode changes
/// </summary>
///--------------------------------------------------------------------------------------------
internal void AdviseDebugger()
{
System.IServiceProvider sp = _site as System.IServiceProvider;
if (sp != null)
{
_debugger = sp.GetService <IVsDebugger, IVsDebugger>();
if (_debugger != null)
{
_debugger.AdviseDebuggerEvents(this, out _debuggerCookie);
DBGMODE[] dbgMode = new DBGMODE[1];
_debugger.GetMode(dbgMode);
((IVsDebuggerEvents)this).OnModeChange(dbgMode[0]);
}
}
}
static void Main(string[] args)
{
IServiceCollection services = new ServiceCollection();
System.IServiceProvider di = services.AddTransient <Car>()
.AddTransient <Engine>(s => new Engine(5))
.BuildServiceProvider();
Car car = di.GetService <Car>();
// or
car = ActivatorUtilities.CreateInstance <Car>(di);
System.Console.WriteLine(car.Engine.HorsePowers);
}
public override object EditValue(ITypeDescriptorContext context, System.IServiceProvider provider, object value)
{
IWindowsFormsEditorService svc = provider.GetService(typeof(IWindowsFormsEditorService)) as IWindowsFormsEditorService;
if (svc != null)
{
IBaseNode baseNode = context.Instance as IBaseNode;
if (baseNode != null)
{
using (DataConnectionForm frm = new DataConnectionForm(baseNode))
{
IDataPersistence dp = getDataPersistence(baseNode);
if (dp != null)
{
IDecisionTree tree = baseNode.Tree;
List <string> Elements = new List <string>();
foreach (string reference in dp.DataConnections)
{
IBaseNode node = tree.GetNodeByReference(reference);
if (node != null)
{
Elements.Add(node.Name);
}
}
frm.Elements = Elements;
if (svc.ShowDialog(frm) == DialogResult.OK)
{
List <string> result = new List <string>();
IBaseNode dataNodes = tree.RootNode.GetNode(eNodeType.DataObjects);
foreach (string name in frm.Elements)
{
IBaseNode dc = dataNodes.GetNode(name);
if (dc != null)
{
result.Add(dc.Reference);
}
}
value = result.ToArray();
}
}
}
}
}
return(value);
}
/// <summary>
/// Called when we want to edit the value of a property. Brings up the Glyph Editor control.
/// </summary>
/// <param name="context"></param>
/// <param name="provider"></param>
/// <param name="value"></param>
/// <returns></returns>
public override object EditValue(System.ComponentModel.ITypeDescriptorContext context, System.IServiceProvider provider, object value)
{
edSvc = (IWindowsFormsEditorService)provider.GetService(typeof(IWindowsFormsEditorService));
if (edSvc != null && value is ArrayList)
{
GlyphEditor glyphEditor = new GlyphEditor();
glyphEditor.Glyphs = value as ArrayList;
if (edSvc.ShowDialog(glyphEditor) == DialogResult.OK)
{
return(new ArrayList(glyphEditor.Glyphs));
}
}
return(value);
}
/// <summary>
/// Overloaded ctor.
/// </summary>
/// <param name="nodeParam">An instance of a project item.</param>
internal FileChangeManager(IServiceProvider serviceProvider)
{
#region input validation
if (serviceProvider == null)
{
throw new ArgumentNullException("serviceProvider");
}
#endregion
this.fileChangeService = (IVsFileChangeEx)serviceProvider.GetService(typeof(SVsFileChangeEx));
if (this.fileChangeService == null)
{
// VS is in bad state, since the SVsFileChangeEx could not be proffered.
throw new InvalidOperationException();
}
}
public AdapterCommand(IVsTextView adapter, System.IServiceProvider provider, Guid menuGroup, uint cmdID, Action commandEvent, Func<bool> queryEvent = null)
{
this.provider = provider;
this.menuGroup = menuGroup;
this.cmdID = cmdID;
this.commandEvent = commandEvent;
this.queryEvent = queryEvent ?? (() => true);
var mcs = provider.GetService(typeof(IMenuCommandService)) as IMenuCommandService;
if (mcs != null)
mcs.AddCommand(menuGroup, (int)cmdID, commandEvent, cmd => {
cmd.Visible = cmd.Enabled = this.queryEvent();
});
Dispatcher.CurrentDispatcher.BeginInvoke(new Action(() =>
{
ErrorHandler.ThrowOnFailure(adapter.AddCommandFilter(this, out nextCommandTarget));
}), DispatcherPriority.ApplicationIdle, null);
}
/// <summary>
/// Attaches events for invoking Statement completion
/// </summary>
public IntellisenseController(IntellisenseControllerProvider provider, ITextView textView, IServiceProvider serviceProvider) {
_textView = textView;
_provider = provider;
_editOps = provider._EditOperationsFactory.GetEditorOperations(textView);
_incSearch = provider._IncrementalSearch.GetIncrementalSearch(textView);
_textView.MouseHover += TextViewMouseHover;
_serviceProvider = serviceProvider;
if (textView.TextBuffer.IsPythonContent()) {
try {
_expansionClient = new ExpansionClient(textView, provider._adaptersFactory, provider._ServiceProvider);
var textMgr = (IVsTextManager2)_serviceProvider.GetService(typeof(SVsTextManager));
textMgr.GetExpansionManager(out _expansionMgr);
} catch (ArgumentException) {
// No expansion client for this buffer, but we can continue without it
}
}
textView.Properties.AddProperty(typeof(IntellisenseController), this); // added so our key processors can get back to us
_textView.Closed += TextView_Closed;
}
/// <include file='doc\ViewFilter.uex' path='docs/doc[@for="TextTipData.TextTipData"]/*' />
internal TextTipData(IServiceProvider site)
{
if (site == null)
throw new System.ArgumentNullException("site");
//this.textView = view;
// Create our method tip window (through the local registry)
Type t = typeof(IVsTextTipWindow);
Guid riid = t.GUID;
Guid clsid = typeof(VsTextTipWindowClass).GUID;
Microsoft.VisualStudio.Shell.Package pkg = (Microsoft.VisualStudio.Shell.Package)site.GetService(typeof(Microsoft.VisualStudio.Shell.Package));
if (pkg == null) {
throw new NullReferenceException(typeof(Microsoft.VisualStudio.Shell.Package).FullName);
}
this.textTipWindow = (IVsTextTipWindow)pkg.CreateInstance(ref clsid, ref riid, t);
if (this.textTipWindow == null)
NativeHelpers.RaiseComError(NativeMethods.E_FAIL);
else
NativeMethods.ThrowOnFailure(textTipWindow.SetTextTipData(this));
}
public XamlTextViewCreationListener(
[Import(typeof(SVsServiceProvider))] System.IServiceProvider services,
ICommandHandlerServiceFactory commandHandlerServiceFactory,
IVsEditorAdaptersFactoryService editorAdaptersFactoryService,
IXamlDocumentAnalyzerService analyzerService,
VisualStudioWorkspaceImpl vsWorkspace)
{
_serviceProvider = services;
_commandHandlerService = commandHandlerServiceFactory;
_editorAdaptersFactory = editorAdaptersFactoryService;
_vsWorkspace = vsWorkspace;
_rdt = new Lazy<RunningDocumentTable>(() => new RunningDocumentTable(_serviceProvider));
_vsSolution = (IVsSolution)_serviceProvider.GetService(typeof(SVsSolution));
AnalyzerService = analyzerService;
uint solutionEventsCookie;
if (ErrorHandler.Succeeded(_vsSolution.AdviseSolutionEvents(this, out solutionEventsCookie)))
{
_solutionEventsCookie = solutionEventsCookie;
}
}
/// <include file='doc\VsShellUtilities.uex' path='docs/doc[@for="VsShellUtilities.OpenDocument"]/*' />
/// <devdoc>
/// Open document using the appropriate project.
/// </devdoc>
/// <param name="provider">The service provider.</param>
/// <param name="fullPath">Full path to the document.</param>
/// <param name="logicalView">GUID identifying the logical view.</param>
/// <param name="hierarchy">Reference to the IVsUIHierarchy interface of the project that contains the Open document.</param>
/// <param name="itemID"> Reference to the hierarchy item identifier of the document in the project.</param>
/// <param name="windowFrame">A reference to the window frame that is mapped to the document.</param>
public static void OpenDocument(IServiceProvider provider, string fullPath, Guid logicalView, out IVsUIHierarchy hierarchy, out uint itemID, out IVsWindowFrame windowFrame)
{
windowFrame = null;
itemID = VSConstants.VSITEMID_NIL;
hierarchy = null;
if (provider == null)
{
throw new ArgumentException("provider");
}
if (String.IsNullOrEmpty(fullPath))
{
throw new ArgumentException("fullPath");
}
//open document
if (!IsDocumentOpen(provider, fullPath, logicalView, out hierarchy, out itemID, out windowFrame))
{
IVsUIShellOpenDocument shellOpenDoc = provider.GetService(typeof(IVsUIShellOpenDocument)) as IVsUIShellOpenDocument;
if (shellOpenDoc != null)
{
IOleServiceProvider psp;
uint itemid;
ErrorHandler.ThrowOnFailure(shellOpenDoc.OpenDocumentViaProject(fullPath, ref logicalView, out psp, out hierarchy, out itemid, out windowFrame));
}
}
if (windowFrame != null)
{
ErrorHandler.ThrowOnFailure(windowFrame.Show());
}
}
static StringDictionary GetLanguageExtensions(IServiceProvider site) {
if (EditorFactory.languageExtensions != null)
return EditorFactory.languageExtensions;
StringDictionary extensions = new StringDictionary();
ILocalRegistry3 localRegistry = site.GetService(typeof(SLocalRegistry)) as ILocalRegistry3;
string root = null;
if (localRegistry != null) {
NativeMethods.ThrowOnFailure(localRegistry.GetLocalRegistryRoot(out root));
}
using (RegistryKey rootKey = Registry.LocalMachine.OpenSubKey(root)) {
if (rootKey != null) {
string relpath = "Languages\\File Extensions";
using (RegistryKey key = rootKey.OpenSubKey(relpath, false)) {
if (key != null) {
foreach (string ext in key.GetSubKeyNames()) {
using (RegistryKey extkey = key.OpenSubKey(ext, false)) {
if (extkey != null) {
string fe = ext;
string guid = extkey.GetValue(null) as string; // get default value
if (!extensions.ContainsKey(fe)) {
extensions.Add(fe, guid);
}
}
}
}
}
}
}
}
return EditorFactory.languageExtensions = extensions;
}
static Hashtable GetEditors(IServiceProvider site) {
if (EditorFactory.editors != null)
return EditorFactory.editors;
Hashtable editors = new Hashtable();
ILocalRegistry3 localRegistry = site.GetService(typeof(SLocalRegistry)) as ILocalRegistry3;
string root = null;
if (localRegistry == null) {
return editors;
}
NativeMethods.ThrowOnFailure(localRegistry.GetLocalRegistryRoot(out root));
using (RegistryKey rootKey = Registry.LocalMachine.OpenSubKey(root)) {
if (rootKey != null) {
RegistryKey editorsKey = rootKey.OpenSubKey("Editors", false);
if (editorsKey != null) {
using (editorsKey) {
foreach (string editorGuid in editorsKey.GetSubKeyNames()) {
Guid guid = GetGuid(editorGuid);
using (RegistryKey editorKey = editorsKey.OpenSubKey(editorGuid, false)) {
object value = editorKey.GetValue(null);
string name = (value != null) ? value.ToString() : editorGuid.ToString();
RegistryKey extensions = editorKey.OpenSubKey("Extensions", false);
if (extensions != null) {
foreach (string s in extensions.GetValueNames()) {
if (!string.IsNullOrEmpty(s)) {
EditorInfo ei = new EditorInfo();
ei.name = name;
ei.guid = guid;
object obj = extensions.GetValue(s);
if (obj is int) {
ei.priority = (int)obj;
}
string ext = (s == "*") ? s : "." + s;
AddEditorInfo(editors, ext.ToLowerInvariant(), ei);
}
}
}
}
}
}
}
}
}
return EditorFactory.editors = editors;
}
/// <include file='doc\VsShellUtilities.uex' path='docs/doc[@for="VsShellUtilities.IsDocumentOpen"]/*' />
/// <devdoc>
/// Determine if a document is opened with a given logical view.
/// </devdoc>
/// <param name="provider">The service provider.</param>
/// <param name="fullPath">Full path to the document</param>
/// <param name="logicalView">GUID identifying the logical view. If logicalView is set to Guid.Empty, it will return true if any view is open.</param>
/// <param name="hierarchy">Reference to the IVsUIHierarchy interface of the project that contains the Open document</param>
/// <param name="itemID"> Reference to the hierarchy item identifier of the document in the project</param>
/// <param name="windowFrame">A reference to the window frame that is mapped to the document</param>
/// <returns>true if the document is open with the given logical view</returns>
public static bool IsDocumentOpen(IServiceProvider provider, string fullPath, Guid logicalView, out IVsUIHierarchy hierarchy, out uint itemID, out IVsWindowFrame windowFrame)
{
windowFrame = null;
itemID = VSConstants.VSITEMID_NIL;
hierarchy = null;
if (provider == null)
{
throw new ArgumentException("provider");
}
if (String.IsNullOrEmpty(fullPath))
{
throw new ArgumentException("fullPath");
}
//open document
IVsUIShellOpenDocument shellOpenDoc = provider.GetService(typeof(IVsUIShellOpenDocument)) as IVsUIShellOpenDocument;
IVsRunningDocumentTable pRDT = provider.GetService(typeof(IVsRunningDocumentTable)) as IVsRunningDocumentTable;
if (pRDT != null && shellOpenDoc != null)
{
IntPtr punkDocData = IntPtr.Zero;
uint docCookie;
uint[] pitemid = new uint[1];
IVsHierarchy ppIVsHierarchy;
try
{
ErrorHandler.ThrowOnFailure(pRDT.FindAndLockDocument((uint)_VSRDTFLAGS.RDT_NoLock, fullPath, out ppIVsHierarchy, out pitemid[0], out punkDocData, out docCookie));
int pfOpen;
uint flags = (logicalView == Guid.Empty) ? (uint)__VSIDOFLAGS.IDO_IgnoreLogicalView : 0;
ErrorHandler.ThrowOnFailure(shellOpenDoc.IsDocumentOpen((IVsUIHierarchy)ppIVsHierarchy, pitemid[0], fullPath, ref logicalView, flags, out hierarchy, pitemid, out windowFrame, out pfOpen));
if (windowFrame != null)
{
itemID = pitemid[0];
return (pfOpen == 1);
}
}
finally
{
if (punkDocData != IntPtr.Zero)
{
Marshal.Release(punkDocData);
}
}
}
return false;
}
/// <include file='doc\VsShellUtilities.uex' path='docs/doc[@for="VsShellUtilities.IsInAutomationFunction"]/*' />
/// <devdoc>
/// Is an extensibility object executing an automation function.
/// </devdoc>
/// <param name="serviceProvider">The service provider.</param>
/// <returns>true if the extensiblity object is executing an automation function.</returns>
public static bool IsInAutomationFunction(IServiceProvider serviceProvider)
{
if (serviceProvider == null)
{
throw new ArgumentException("serviceProvider");
}
IVsExtensibility extensibility = serviceProvider.GetService(typeof(IVsExtensibility)) as IVsExtensibility;
if (extensibility == null)
{
throw new InvalidOperationException();
}
return (extensibility.IsInAutomationFunction() == 0) ? false : true;
}
/// <include file='doc\VsShellUtilities.uex' path='docs/doc[@for="VsShellUtilities.IsSolutionBuilding"]/*' />
/// <devdoc>
/// Is current solution building or deploying
/// </devdoc>
/// <param name="serviceProvider">The service provider</param>
/// <returns>true if solution is building or deploying.</returns>
public static bool IsSolutionBuilding(IServiceProvider serviceProvider)
{
if (serviceProvider == null)
{
throw new ArgumentException("serviceProvider");
}
IVsSolutionBuildManager solutionBuildManager = serviceProvider.GetService(typeof(IVsSolutionBuildManager)) as IVsSolutionBuildManager;
if (solutionBuildManager == null)
{
throw new InvalidOperationException();
}
int returnValueAsInteger = 0;
ErrorHandler.ThrowOnFailure(solutionBuildManager.QueryBuildManagerBusy(out returnValueAsInteger));
return (returnValueAsInteger == 1);
}
/// <summary>
/// Updates the caption for all windows associated to the document.
/// </summary>
/// <param name="site">The service provider.</param>
/// <param name="caption">The new caption.</param>
/// <param name="docData">The IUnknown interface to a document data object associated with a registered document.</param>
public static void UpdateCaption(IServiceProvider site, string caption, IntPtr docData)
{
if(site == null)
{
throw new ArgumentNullException("site");
}
if(String.IsNullOrEmpty(caption))
{
throw new ArgumentException(SR.GetString(SR.ParameterCannotBeNullOrEmpty, CultureInfo.CurrentUICulture), "caption");
}
IVsUIShell uiShell = site.GetService(typeof(SVsUIShell)) as IVsUIShell;
// We need to tell the windows to update their captions.
IEnumWindowFrames windowFramesEnum;
ErrorHandler.ThrowOnFailure(uiShell.GetDocumentWindowEnum(out windowFramesEnum));
IVsWindowFrame[] windowFrames = new IVsWindowFrame[1];
uint fetched;
while(windowFramesEnum.Next(1, windowFrames, out fetched) == VSConstants.S_OK && fetched == 1)
{
IVsWindowFrame windowFrame = windowFrames[0];
object data;
ErrorHandler.ThrowOnFailure(windowFrame.GetProperty((int)__VSFPROPID.VSFPROPID_DocData, out data));
IntPtr ptr = Marshal.GetIUnknownForObject(data);
try
{
if(ptr == docData)
{
ErrorHandler.ThrowOnFailure(windowFrame.SetProperty((int)__VSFPROPID.VSFPROPID_OwnerCaption, caption));
}
}
finally
{
if(ptr != IntPtr.Zero)
{
Marshal.Release(ptr);
}
}
}
}
/// <include file='doc\VsShellUtilities.uex' path='docs/doc[@for="VsShellUtilities.LaunchDebugger"]/*' />
/// <devdoc>
/// Launch the debugger.
/// </devdoc>
/// <param name="serviceProvider">The service provider.</param>
/// <param name="info">A reference to a VsDebugTargetInfo object.</param>
public static void LaunchDebugger(IServiceProvider serviceProvider, VsDebugTargetInfo info)
{
Debug.Assert(serviceProvider != null, "Cannot launch the debugger on an empty service provider");
if (serviceProvider == null)
{
throw new ArgumentException("serviceProvider");
}
info.cbSize = (uint)Marshal.SizeOf(info);
IntPtr ptr = Marshal.AllocCoTaskMem((int)info.cbSize);
Marshal.StructureToPtr(info, ptr, false);
try
{
IVsDebugger d = serviceProvider.GetService(typeof(IVsDebugger)) as IVsDebugger;
Debug.Assert(d != null, "Could not retrieve IVsDebugger from " + serviceProvider.GetType().Name);
if (d == null)
{
throw new InvalidOperationException();
}
ErrorHandler.ThrowOnFailure(d.LaunchDebugTargets(1, ptr));
}
catch (COMException e)
{
Trace.WriteLine("Exception : " + e.Message);
}
finally
{
if (ptr != IntPtr.Zero)
{
Marshal.FreeCoTaskMem(ptr);
}
}
}