public SolutionService([Import(typeof(SVsServiceProvider))] IServiceProvider serviceProvider)
{
ThreadHelper.ThrowIfNotOnUIThread();
_vsSolution1 = serviceProvider.GetService <SVsSolution, IVsSolution>();
_vsSolution2 = serviceProvider.GetService <SVsSolution, IVsSolution2>();
_vsSolution4 = serviceProvider.GetService <SVsSolution, IVsSolution4>();
_vsImageService2 = serviceProvider.GetService <SVsImageService, IVsImageService2>();
_vsSolution1.AdviseSolutionEvents(this, out _solutionEvents1Cookie);
_vsSolution1.AdviseSolutionEvents(this, out _solutionEvents4Cookie);
}
/// <summary>
/// Initialization of the package; this method is called right after the package is sited.
/// </summary>
protected override void Initialize()
{
Debug.WriteLine(string.Format(CultureInfo.CurrentCulture, "Entering Initialize() of: {0}", this.ToString()));
base.Initialize();
IVsSolution solution = (IVsSolution)GetService(typeof(SVsSolution));
ErrorHandler.ThrowOnFailure(solution.AdviseSolutionEvents(this, out solutionCookie));
// Add our command handlers for menu (commands must exist in the .vsct file)
OleMenuCommandService mcs = (OleMenuCommandService)GetService(typeof(IMenuCommandService)) as OleMenuCommandService;
if (null != mcs)
{
// Create the command for the menu item.
CommandID menuCommandID = new CommandID(GuidList.guidLocalHistoryCmdSet, (int)PkgCmdIDList.cmdidLocalHistoryMenuItem);
MenuCommand menuItem = new MenuCommand(ProjectItemContextMenuHandler, menuCommandID);
mcs.AddCommand(menuItem);
// Create the command for the tool window
CommandID toolwndCommandID = new CommandID(GuidList.guidLocalHistoryCmdSet, (int)PkgCmdIDList.cmdidLocalHistoryWindow);
MenuCommand menuToolWin = new MenuCommand(ToolWindowMenuItemHandler, toolwndCommandID);
mcs.AddCommand(menuToolWin);
}
}
/// <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()
{
base.Initialize();
AppDomain.CurrentDomain.UnhandledException += (sender, e) => Helpers.LogException(e.ExceptionObject as Exception);
solutionService = (IVsSolution)GetService(typeof(SVsSolution));
solutionService.AdviseSolutionEvents(this, out var cookie);
var tpdService = (IVsTrackProjectDocuments2)GetService(typeof(SVsTrackProjectDocuments));
tpdService.AdviseTrackProjectDocumentsEvents(this, out var tpdCookie);
UiShell = (IVsUIShell)GetService(typeof(SVsUIShell));
InitializeOptionsStorage();
runningDocumentTable = GetService(typeof(SVsRunningDocumentTable)) as IVsRunningDocumentTable;
runningDocumentTable.AdviseRunningDocTableEvents(this, out var rdtCookie);
shellOpenDocument = GetService(typeof(SVsUIShellOpenDocument)) as IVsUIShellOpenDocument;
InitializeMenu();
InitializeCommands();
var componentModel = (IComponentModel)GetService(typeof(SComponentModel));
var editorAdaptersFactoryService = componentModel.GetService <IVsEditorAdaptersFactoryService>();
var textManager = (IVsTextManager)GetService(typeof(SVsTextManager));
BookmarksManager.InitializeAfterPackageInitialization(editorAdaptersFactoryService, textManager);
}
public SolutionEventsListener(IServiceProvider serviceProvider)
{
InitNullEvents();
Solution = serviceProvider.GetService(typeof(SVsSolution)) as IVsSolution;
Solution?.AdviseSolutionEvents(this, out SolutionEventsCookie);
}
/////////////////////////////////////////////////////////////////////////////
// Overridden Package Implementation
/// <summary>
/// Initialization of the package; this method is called right after the package is sited, so this is the place
/// where you can put all the initialization code that rely on services provided by VisualStudio.
/// </summary>
protected override void Initialize()
{
Debug.WriteLine(string.Format(CultureInfo.CurrentCulture, "Entering Initialize() of: {0}", this.ToString()));
base.Initialize();
// listen for solution events
_solution = (IVsSolution)GetService(typeof(SVsSolution));
ErrorHandler.ThrowOnFailure(_solution.AdviseSolutionEvents(this, out _solutionCookie));
_dte = (DTE)GetService(typeof(SDTE));
var events = _dte.Events;
_buildEvents = events.BuildEvents;
if (_errorListProvider == null)
{
_errorListProvider = new ErrorListProvider(this);
}
Dispatcher.CurrentDispatcher.BeginInvoke(new Action(() =>
{
Options = (ShowMissingOptions)GetDialogPage(typeof(ShowMissingOptions));
}), DispatcherPriority.ApplicationIdle, null);
_buildEvents.OnBuildProjConfigBegin += BuildEventsOnOnBuildProjConfigBegin;
_buildEvents.OnBuildBegin += BuildEventsOnOnBuildBegin;
_buildEvents.OnBuildDone += BuildEventsOnOnBuildDone;
}
protected override void Initialize()
{
base.Initialize();
// Initialize common functionality
Common.Initialize(this);
taskListMenu = new RootMenu();
// Initialize fields
tools = new Tools();
sharedTaskManagers = new List <TaskManager>();
// Attach to solution events
solution = GetService(typeof(SVsSolution)) as IVsSolution;
// if (solution == null) throw new NullReferenceException();
solution.AdviseSolutionEvents(this as IVsSolutionEvents, out solutionEventsCookie);
// Attach to build events
buildManager = GetService(typeof(SVsSolutionBuildManager)) as IVsSolutionBuildManager;
// if (buildManager == null) throw new NullReferenceException();
buildManager.AdviseUpdateSolutionEvents(this, out buildManagerCookie);
// Add a TaskManagerFactory service
(this as System.ComponentModel.Design.IServiceContainer).AddService(typeof(ITaskManagerFactory), this, true);
}
internal SolutionEvents()
{
ThreadHelper.ThrowIfNotOnUIThread();
IVsSolution svc = VS.GetRequiredService <SVsSolution, IVsSolution>();
svc.AdviseSolutionEvents(this, out _);
}
protected override void Initialize()
{
_solution = GetService(typeof(SVsSolution)) as IVsSolution;
_solution.AdviseSolutionEvents(this, out _hSolutionEvents);
base.Initialize();
}
internal void Register()
{
// Register this object to listen for IVsUpdateSolutionEvents
IVsSolutionBuildManager2 buildManager = Package.GetService <SVsSolutionBuildManager, IVsSolutionBuildManager2>();
if (buildManager == null)
{
throw Marshal.GetExceptionForHR(E_FAIL);
}
buildManager.AdviseUpdateSolutionEvents(this, out m_updateSolutionEventsCookie);
// Register this object to listen for IVsSolutionEvents
IVsSolution solution = Package.GetService <SVsSolution, IVsSolution>();
if (solution == null)
{
throw Marshal.GetExceptionForHR(E_FAIL);
}
solution.AdviseSolutionEvents(this, out m_solutionEventsCookie);
// Register this object to listen for IVsRunningDocTableEvents
_runningDocTable = Package.GetService <SVsRunningDocumentTable, IVsRunningDocumentTable>();
if (_runningDocTable == null)
{
throw Marshal.GetExceptionForHR(E_FAIL);
}
_runningDocTable.AdviseRunningDocTableEvents(this, out m_runningDocTableEventsCookie);
}
public async Task InitializeAsync()
{
await _threadHandling.Value.SwitchToUIThread();
// Initialize our cache file
string appDataFolder = await _shellUtilitiesHelper.Value.GetLocalAppDataFolderAsync(_serviceProvider).ConfigureAwait(true);
if (appDataFolder != null)
{
_versionDataCacheFile = new RemoteCacheFile(Path.Combine(appDataFolder, VersionDataFilename), VersionCompatibilityDownloadFwlink,
TimeSpan.FromHours(CacheFileValidHours), _fileSystem.Value, _httpClient);
}
_ourVSVersion = await _shellUtilitiesHelper.Value.GetVSVersionAsync(_serviceProvider).ConfigureAwait(true);
IVsSolution solution = _serviceProvider.GetService <IVsSolution, SVsSolution>();
Verify.HResult(solution.AdviseSolutionEvents(this, out _solutionCookie));
// Check to see if a solution is already open. If so we set _solutionOpened to true so that subsequent projects added to
// this solution are processed.
if (ErrorHandler.Succeeded(solution.GetProperty((int)__VSPROPID4.VSPROPID_IsSolutionFullyLoaded, out object isFullyLoaded)) && isFullyLoaded is bool && (bool)isFullyLoaded)
{
_solutionOpened = true;
}
}
public TeamPilgrimVsService(TeamPilgrimPackage packageInstance, IVsUIShell vsUiShell, DTE2 dte2, IVsSolution vsSolution)
{
_teamFoundationBuild = new Lazy <VsTeamFoundationBuildWrapper>(() => new VsTeamFoundationBuildWrapper(_packageInstance.GetPackageService <IVsTeamFoundationBuild>()));
_portalSettingsLauncher = new Lazy <IPortalSettingsLauncher>(() => _packageInstance.GetPackageService <IPortalSettingsLauncher>());
_sourceControlSettingsLauncher = new Lazy <ISourceControlSettingsLauncher>(() => _packageInstance.GetPackageService <ISourceControlSettingsLauncher>());
_processTemplateManagerLauncher = new Lazy <IProcessTemplateManagerLauncher>(() => _packageInstance.GetPackageService <IProcessTemplateManagerLauncher>());
_workItemTrackingPackage = new Lazy <WorkItemTrackingPackageWrapper>();
_versionControlPackage = new Lazy <VersionControlPackageWrapper>();
_querySecurityCommandHelpers = new Lazy <QuerySecurityCommandHelpersWrapper>();
_pendingChangesPageViewModelUtilsWrapper = new Lazy <PendingChangesPageViewModelUtilsWrapper>();
VsUiShell = vsUiShell;
_packageInstance = packageInstance;
Dte2 = dte2;
VsSolution = vsSolution;
VersionControlExt = dte2.GetObject("Microsoft.VisualStudio.TeamFoundation.VersionControl.VersionControlExt") as VersionControlExt;
TeamFoundationServerExt = dte2.GetObject("Microsoft.VisualStudio.TeamFoundation.TeamFoundationServerExt") as TeamFoundationServerExt;
WorkItemTrackingDocumentService = new DocumentServiceWrapper(dte2.GetObject("Microsoft.VisualStudio.TeamFoundation.WorkItemTracking.DocumentService") as DocumentService);
var teamFoundationHostObject = (ITeamFoundationContextManager)TeamFoundationServerExt_TeamFoundationHostField.Value.GetValue(TeamFoundationServerExt);
TeamFoundationHost = new TeamFoundationHostWrapper(teamFoundationHostObject);
vsSolution.AdviseSolutionEvents(this, out _adviseSolutionEventsCookie);
}
/////////////////////////////////////////////////////////////////////////////
// Overridden Package Implementation
/// <summary>
/// Initialization of the package; this method is called right after the package is sited, so this is the place
/// where you can put all the initialization code that rely on services provided by VisualStudio.
/// </summary>
protected override void Initialize()
{
Debug.WriteLine(string.Format(CultureInfo.CurrentCulture, "Entering Initialize() of: {0}", ToString()));
base.Initialize();
#if MEMPROFILER
RedGate.MemoryProfiler.Snapshot.TakeSnapshot("Initialize");
#endif
// listen for solution events
_solution = (IVsSolution)GetService(typeof(SVsSolution));
ErrorHandler.ThrowOnFailure(_solution.AdviseSolutionEvents(this, out _solutionCookie));
if (_errorListProvider == null)
{
_errorListProvider = new TaskProvider(this);
}
// Commands
IncludeFileCommand.Initialize(this, _errorListProvider);
DeleteFileCommand.Initialize(this, _errorListProvider);
ExcludeFileCommand.Initialize(this, _errorListProvider);
_dte = (DTE)GetService(typeof(SDTE));
var events = _dte.Events;
_buildEvents = events.BuildEvents;
Options = (OptionsDialogPage)GetDialogPage(typeof(OptionsDialogPage));
_buildEvents.OnBuildProjConfigBegin += BuildEventsOnOnBuildProjConfigBegin;
_buildEvents.OnBuildProjConfigDone += BuildEventsOnBuildProjConfigDone;
_buildEvents.OnBuildBegin += BuildEventsOnOnBuildBegin;
_buildEvents.OnBuildDone += BuildEventsOnOnBuildDone;
}
public VisualStudioProjectTracker(IServiceProvider serviceProvider)
{
_projectMap = new Dictionary<ProjectId, AbstractProject>();
_projectPathToIdMap = new Dictionary<string, ProjectId>(StringComparer.OrdinalIgnoreCase);
_serviceProvider = serviceProvider;
_workspaceHosts = new List<WorkspaceHostState>(capacity: 1);
_vsSolution = (IVsSolution)serviceProvider.GetService(typeof(SVsSolution));
_runningDocumentTable = (IVsRunningDocumentTable4)serviceProvider.GetService(typeof(SVsRunningDocumentTable));
uint solutionEventsCookie;
_vsSolution.AdviseSolutionEvents(this, out solutionEventsCookie);
_solutionEventsCookie = solutionEventsCookie;
// It's possible that we're loading after the solution has already fully loaded, so see if we missed the event
var shellMonitorSelection = (IVsMonitorSelection)serviceProvider.GetService(typeof(SVsShellMonitorSelection));
uint fullyLoadedContextCookie;
if (ErrorHandler.Succeeded(shellMonitorSelection.GetCmdUIContextCookie(VSConstants.UICONTEXT.SolutionExistsAndFullyLoaded_guid, out fullyLoadedContextCookie)))
{
int fActive;
if (ErrorHandler.Succeeded(shellMonitorSelection.IsCmdUIContextActive(fullyLoadedContextCookie, out fActive)) && fActive != 0)
{
_solutionLoadComplete = true;
}
}
}
/// <summary>
/// Initializes a new instance of the <see cref="LocatorWindowCommand"/> class.
/// Adds our command handlers for menu (commands must exist in the command table file)
/// </summary>
/// <param name="package">Owner package, not null.</param>
private LocatorWindowCommand(Package package)
{
if (package == null)
{
throw new ArgumentNullException("package");
}
this.package = package;
OleMenuCommandService commandService = ServiceProvider.GetService(typeof(IMenuCommandService)) as OleMenuCommandService;
if (commandService != null)
{
var menuCommandID = new CommandID(CommandSet, CommandId);
var menuItem = new MenuCommand(this.ShowToolWindow, menuCommandID);
commandService.AddCommand(menuItem);
}
// Get the instance number 0 of this tool window. This window is single instance so this instance
// is actually the only one.
// The last flag is set to true so that if the tool window does not exists it will be created.
_locatorWindow = package.FindToolWindow(typeof(LocatorWindow), 0, true) as LocatorWindow;
if ((null == _locatorWindow) || (null == _locatorWindow.Frame))
{
throw new NotSupportedException("Cannot create tool window");
}
_locator = new Locator();
_solution = ServiceProvider.GetService(typeof(SVsSolution)) as IVsSolution;
_solution.AdviseSolutionEvents(_locator, out _cookie);
_locatorWindow.SetLocator(_locator);
_locator.StartWorkerThread();
}
protected override async System.Threading.Tasks.Task InitializeAsync(CancellationToken cancellationToken, IProgress <ServiceProgressData> progress)
{
await base.InitializeAsync(cancellationToken, progress);
// NOTE: this switch is already performed within the base.InitializeAsync() method.
await Microsoft.VisualStudio.Shell.ThreadHelper.JoinableTaskFactory.SwitchToMainThreadAsync(cancellationToken);
_CurrentSolutionRcsType = RcsType.Unknown;
//EnvDTE.IVsExtensibility extensibility = await GetServiceAsync(typeof(EnvDTE.IVsExtensibility)) as EnvDTE.IVsExtensibility;
//_DTE2 = (DTE2)extensibility.GetGlobalsObject(null).DTE as EnvDTE80.DTE2;
_DTE2 = Package.GetGlobalService(typeof(DTE)) as DTE2;
IVsSolution solution = await GetServiceAsync(typeof(SVsSolution)) as IVsSolution;
Assumes.Present(solution);
int hr;
uint pdwCookie;
hr = solution.AdviseSolutionEvents(this, out pdwCookie);
Marshal.ThrowExceptionForHR(hr);
_VsShell = await GetServiceAsync(typeof(SVsShell)) as IVsShell;
_VsRegisterScciProvider = await GetServiceAsync(typeof(IVsRegisterScciProvider)) as IVsRegisterScciProvider;
_VsGetScciProviderInterface = await GetServiceAsync(typeof(IVsRegisterScciProvider)) as IVsGetScciProviderInterface;
_SettingsStore = GetWritableSettingsStore();
TaskManager.Initialize(this);
solutionEvents = ((Events2)_DTE2.Events).SolutionEvents;
solutionEvents.Opened += new _dispSolutionEvents_OpenedEventHandler(this.SolutionEvents_Opened);
SolutionEvents_Opened();
}
protected override void Initialize()
{
base.Initialize();
_updateLock = new object();
IVsExtensibility extensibility = GetService <IVsExtensibility>();
_DTE2 = (DTE2)extensibility.GetGlobalsObject(null).DTE;
_Version = GetVersion(_DTE2.Version);
_Solution = GetService <SVsSolution>() as IVsSolution;
IVsCfgProvider2 test = _Solution as IVsCfgProvider2;
_SolutionEvents = new SolutionEvents();
int hr;
uint pdwCookie;
hr = _Solution.AdviseSolutionEvents(_SolutionEvents, out pdwCookie);
Marshal.ThrowExceptionForHR(hr);
_UpdateSolutionEvents = new UpdateSolutionEvents();
var vsSolutionBuildManager = GetService <SVsSolutionBuildManager>();
hr = (vsSolutionBuildManager as IVsSolutionBuildManager3).AdviseUpdateSolutionEvents3(_UpdateSolutionEvents, out pdwCookie);
Marshal.ThrowExceptionForHR(hr);
hr = (vsSolutionBuildManager as IVsSolutionBuildManager2).AdviseUpdateSolutionEvents(_UpdateSolutionEvents, out pdwCookie);
Marshal.ThrowExceptionForHR(hr);
if (VersionGreaterEqualTo(DTEVersion.VS15))
{
LoadMef();
}
}
internal void InitProjectInfos(SVsServiceProvider provider, ABnfFactory factory)
{
if (factory == null)
{
return;
}
if (m_server != null)
{
return;
}
m_server = new ALanguageServer();
m_server.Start(factory);
if (m_cookie != 0)
{
return;
}
if (m_solution != null)
{
return;
}
m_solution = provider.GetService(typeof(SVsSolution)) as IVsSolution;
if (m_solution == null)
{
return;
}
m_dot_ext = factory.GetDotExt();
m_file_icon = factory.GetFileIcon();
// 读取所有工程
m_projects.Clear();
Guid rguidEnumOnlyThisType = new Guid();
IEnumHierarchies ppenum = null;
m_solution.GetProjectEnum((uint)__VSENUMPROJFLAGS.EPF_LOADEDINSOLUTION, ref rguidEnumOnlyThisType, out ppenum);
IVsHierarchy[] rgelt = new IVsHierarchy[1];
uint pceltFetched = 0;
while (ppenum.Next(1, rgelt, out pceltFetched) == VSConstants.S_OK && pceltFetched == 1)
{
IVsSccProject2 sccProject2 = rgelt[0] as IVsSccProject2;
if (sccProject2 != null)
{
string project_path = GetProjectPath(rgelt[0]);
if (project_path != null)
{
if (m_server != null)
{
m_server.AddTask(() => m_server.AddProjectInfo(project_path));
}
m_projects[rgelt[0]] = new UIProjectInfo(this, rgelt[0], project_path, m_dot_ext, m_file_icon);
}
}
}
// 监听工程变化
m_solution.AdviseSolutionEvents(this, out m_cookie);
}
private void AdviseSolutionEvents()
{
UnadviseSolutionEvents();
solution = GetService(typeof(SVsSolution)) as IVsSolution;
solution?.AdviseSolutionEvents(this, out _handleCookie);
}
public async Task InitializeAsync()
{
await _threadHandling.Value.SwitchToUIThread();
// Initialize our cache file
string appDataFolder = await _shellUtilitiesHelper.Value.GetLocalAppDataFolderAsync(_vsShellService);
if (appDataFolder != null)
{
_versionDataCacheFile = new RemoteCacheFile(Path.Combine(appDataFolder, VersionDataFilename), VersionCompatibilityDownloadFwlink,
TimeSpan.FromHours(CacheFileValidHours), _fileSystem.Value, _httpClient);
}
_ourVSVersion = await _shellUtilitiesHelper.Value.GetVSVersionAsync(_vsAppIdService);
_vsSolution = await _vsSolutionService.GetValueAsync();
Verify.HResult(_vsSolution.AdviseSolutionEvents(this, out _solutionCookie));
// Check to see if a solution is already open. If so we set _solutionOpened to true so that subsequent projects added to
// this solution are processed.
if (ErrorHandler.Succeeded(_vsSolution.GetProperty((int)__VSPROPID4.VSPROPID_IsSolutionFullyLoaded, out object isFullyLoaded)) &&
isFullyLoaded is bool isFullyLoadedBool &&
isFullyLoadedBool)
{
_solutionOpened = true;
// do not block package initialization on this
_threadHandling.Value.RunAndForget(() => CheckCompatibilityAsync(), unconfiguredProject: null);
}
}
/// <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 cancellationToken, IProgress <ServiceProgressData> progress)
{
await InitComponentsAsync();
OleMenuCommandService commandService = await base.GetServiceAsync(typeof(IMenuCommandService)) as OleMenuCommandService;
MainPanelCommand.Initialize(this, commandService);
await base.InitializeAsync(cancellationToken, progress);
// Switch to main thread for dealing with type IVsSolution.
await ThreadHelper.JoinableTaskFactory.SwitchToMainThreadAsync();
_solution = base.GetService(typeof(SVsSolution)) as IVsSolution;
if (_solution != null)
{
_solutionEventsHandler = new SolutionEventsHandler();
_solution.AdviseSolutionEvents(_solutionEventsHandler, out _solutionEventsCookie);
}
// To trigger upon loading a solution
object objLoadMgr = this; //the class that implements IVsSolutionManager
IVsSolution pSolution = GetService(typeof(SVsSolution)) as IVsSolution;
object existingLoadManager = null;
pSolution.GetProperty((int)__VSPROPID4.VSPROPID_ActiveSolutionLoadManager, out existingLoadManager);
pSolution.SetProperty((int)__VSPROPID4.VSPROPID_ActiveSolutionLoadManager, objLoadMgr);
}
public VisualStudioProjectTracker(IServiceProvider serviceProvider, HostWorkspaceServices workspaceServices)
: base(assertIsForeground: true)
{
_projectMap = new Dictionary <ProjectId, AbstractProject>();
_projectPathToIdMap = new Dictionary <string, ProjectId>(StringComparer.OrdinalIgnoreCase);
_serviceProvider = serviceProvider;
_workspaceHosts = new List <WorkspaceHostState>(capacity: 1);
_workspaceServices = workspaceServices;
_vsSolution = (IVsSolution)serviceProvider.GetService(typeof(SVsSolution));
_runningDocumentTable = (IVsRunningDocumentTable4)serviceProvider.GetService(typeof(SVsRunningDocumentTable));
_vsSolution.AdviseSolutionEvents(this, out var solutionEventsCookie);
_solutionEventsCookie = solutionEventsCookie;
// It's possible that we're loading after the solution has already fully loaded, so see if we missed the event
var shellMonitorSelection = (IVsMonitorSelection)serviceProvider.GetService(typeof(SVsShellMonitorSelection));
if (ErrorHandler.Succeeded(shellMonitorSelection.GetCmdUIContextCookie(VSConstants.UICONTEXT.SolutionExistsAndFullyLoaded_guid, out var fullyLoadedContextCookie)))
{
if (ErrorHandler.Succeeded(shellMonitorSelection.IsCmdUIContextActive(fullyLoadedContextCookie, out var fActive)) && fActive != 0)
{
_solutionLoadComplete = true;
}
}
}
/// <summary>
/// Initializes a new instance of the <see cref="FuzzyOpenCommand"/> class.
/// Adds our command handlers for menu (commands must exist in the command table file)
/// </summary>
/// <param name="package">Owner package, not null.</param>
private FuzzyOpenCommand(Package package)
{
if (package == null)
{
throw new ArgumentNullException("package");
}
this.package = package;
mDTE = FuzzyOpenPackage.GetGlobalService(typeof(DTE)) as DTE;
mAllItems = mLoadAllFiles();
mSvs = FuzzyOpenPackage.GetGlobalService(typeof(SVsSolution)) as IVsSolution;
if (mSvs != null)
{
mSvs.AdviseSolutionEvents(this, out mAdviseId);
}
((EnvDTE80.Events2)mDTE.Events).ProjectItemsEvents.ItemAdded += ProjectItemsEvents_ItemAdded;
((EnvDTE80.Events2)mDTE.Events).ProjectItemsEvents.ItemRemoved += ProjectItemsEvents_ItemRemoved;
((EnvDTE80.Events2)mDTE.Events).ProjectItemsEvents.ItemRenamed += ProjectItemsEvents_ItemRenamed;
//((EnvDTE80.Events2)mDTE.Events).ProjectsEvents.ItemAdded TODO
//((EnvDTE80.Events2)mDTE.Events).ProjectsEvents.ItemRemoved
//((EnvDTE80.Events2)mDTE.Events).ProjectsEvents.ItemRenamed
OleMenuCommandService commandService = this.ServiceProvider.GetService(typeof(IMenuCommandService)) as OleMenuCommandService;
if (commandService != null)
{
var menuCommandID = new CommandID(CommandSet, CommandId);
var menuItem = new MenuCommand(this.MenuItemCallback, menuCommandID);
commandService.AddCommand(menuItem);
}
}
/// <include file='doc\ShellLicenseManagerService.uex' path='docs/doc[@for="ShellLicenseManagerService.ShellLicenseManagerService"]/*' />
/// <devdoc>
/// Creates a new type loader service.
/// </devdoc>
public ShellLicenseManagerService(IServiceProvider provider)
{
this.provider = provider;
// We need to track solution events.
//
IVsSolution sol = (IVsSolution)GetService(typeof(IVsSolution));
#if DEBUG
if (Switches.LICMANAGER.TraceVerbose)
{
if (sol == null)
{
Debug.WriteLine("ShellLicenseManager : No solution found");
}
else
{
Debug.WriteLine("ShellLicenseManager : Attaching solution events");
}
}
#endif
if (sol != null)
{
solutionEventsCookie = sol.AdviseSolutionEvents(this);
}
}
/// <include file='doc\ShellTypeLoaderService.uex' path='docs/doc[@for="ShellTypeLoaderService.ShellTypeLoaderService"]/*' />
/// <devdoc>
/// Creates a new type loader service.
/// </devdoc>
public ShellTypeLoaderService(IServiceProvider provider)
{
this.provider = provider;
// We need to track solution events.
//
IVsSolution sol = (IVsSolution)GetService(typeof(IVsSolution));
#if DEBUG
if (Switches.TYPELOADER.TraceVerbose)
{
if (sol == null)
{
Debug.WriteLine("TypeLoader : No solution found");
}
else
{
Debug.WriteLine("TypeLoader : Attaching solution events");
}
}
#endif
if (sol != null)
{
solutionEventsCookie = sol.AdviseSolutionEvents(this);
}
ShellTypeLoader.ClearProjectAssemblyCache();
}
/// <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 System.Threading.Tasks.Task InitializeAsync(CancellationToken cancellationToken, IProgress <ServiceProgressData> progress)
{
await base.InitializeAsync(cancellationToken, progress);
_dte = await GetServiceAsync <DTE>();
var serviceProvider = new ServiceProvider((Microsoft.VisualStudio.OLE.Interop.IServiceProvider)_dte);
var dialogService = new VisualStudioDialogService(serviceProvider);
var commandService = await GetServiceAsync <IMenuCommandService>();
var projectService = new VcProjectService();
var settingsService = new VisualStudioSettingsService(this);
_solution = await GetServiceAsync <SVsSolution>() as IVsSolution;
_solutionEventsHandler = new SolutionEventsHandler(this);
_solution.AdviseSolutionEvents(_solutionEventsHandler, out var _solutionEventsCookie);
_addConanDepends = new AddConanDepends(commandService, dialogService, projectService, settingsService);
_showPackageListCommand = new ShowPackageListCommand(this, commandService, dialogService);
_integrateIntoProjectCommand = new IntegrateIntoProjectCommand(commandService, dialogService, projectService);
Logger.Initialize(serviceProvider, "Conan");
SubscribeToEvents();
}
public SolutionsEventListener(GaugeDaemonOptions gaugeDaemonOptions, IServiceProvider serviceProvider)
{
ThreadHelper.ThrowIfNotOnUIThread();
_gaugeDaemonOptions = gaugeDaemonOptions;
_solution = serviceProvider.GetService(typeof(SVsSolution)) as IVsSolution;
ErrorHandler.ThrowOnFailure(_solution.AdviseSolutionEvents(this, out _solutionCookie));
}
public SolutionEventsListener(IServiceProvider serviceProvider)
{
_solution = serviceProvider.GetService(typeof(SVsSolution)) as IVsSolution;
#pragma warning disable VSTHRD010 // Invoke single-threaded types on Main thread
_solution?.AdviseSolutionEvents(this, out _solutionEventsCookie);
#pragma warning restore VSTHRD010 // Invoke single-threaded types on Main thread
}
public SolutionEvent(IVsSolution Solution, EnvDTE.DTE ctxDte)
{
Microsoft.VisualStudio.Shell.ThreadHelper.ThrowIfNotOnUIThread();
dte = ctxDte;
Solution.AdviseSolutionEvents(this, out cookie);
}
/// <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 initilaization code that rely on services provided by VisualStudio.
/// </summary>
protected override void Initialize()
{
ToolStripManager.Renderer = new VisualStudioLikeToolStripRenderer();
// Add the Text Marker Service to the service container. The container will care
// about all the rest (proffer the service, revoke it, and so on).
CloneMarkerTypeProvider markerTypeProvider = new CloneMarkerTypeProvider();
((IServiceContainer)this).AddService(markerTypeProvider.GetType(), markerTypeProvider, true);
base.Initialize();
// Add our command handlers for menu (commands must exist in the .vsct file)
OleMenuCommandService mcs = GetService(typeof(IMenuCommandService)) as OleMenuCommandService;
if (null != mcs)
{
// Create the commands for the tool windows.
CommandID cloneExplorerCommandID = new CommandID(Guids.GuidCommandSet, (int)PkgCmdid.CmdidCloneExplorer);
MenuCommand cloneExplorerMenuItem = new MenuCommand(ShowCloneExplorer, cloneExplorerCommandID);
mcs.AddCommand(cloneExplorerMenuItem);
CommandID cloneIntersectionsCommandID = new CommandID(Guids.GuidCommandSet, (int)PkgCmdid.CmdidCloneIntersections);
MenuCommand cloneIntersectionsMenuItem = new MenuCommand(ShowCloneIntersections, cloneIntersectionsCommandID);
mcs.AddCommand(cloneIntersectionsMenuItem);
CommandID cloneResultsCommandID = new CommandID(Guids.GuidCommandSet, (int)PkgCmdid.CmdidCloneResults);
MenuCommand cloneResultsMenuItem = new MenuCommand(ShowCloneResults, cloneResultsCommandID);
mcs.AddCommand(cloneResultsMenuItem);
}
// Advise event sinks. We need to know when a solution is opened and closed
// (SolutionEventSink), when a document is opened and closed (TextManagerEventSink),
// and when a document is saved (RunningDocTableEventSink).
//
// However unfortunately we can't advise the text manager event sink here due to a very
// strange constellation: On Windows XP running "devenv /setup" usually works fine but
// sometimes destruction of the text manager service crashes VS. The solution is to defer
// event sink registration to the point in time when the first solution is loaded. This works
// as solutions are only loaded in interactive mode and we don't have any work to do as long
// as there is no active solution.
SolutionEventSink solutionEventSink = new SolutionEventSink();
RunningDocTableEventSink runningDocTableEventSink = new RunningDocTableEventSink();
IVsSolution solution = (IVsSolution)GetService(typeof(SVsSolution));
ErrorHandler.ThrowOnFailure(solution.AdviseSolutionEvents(solutionEventSink, out _solutionEventCookie));
IVsRunningDocumentTable rdt = (IVsRunningDocumentTable)GetService(typeof(SVsRunningDocumentTable));
ErrorHandler.ThrowOnFailure(rdt.AdviseRunningDocTableEvents(runningDocTableEventSink, out _rdtEventCookie));
// Since we register custom text markers we have to ensure the font and color
// cache is up-to-date.
ValidateFontAndColorCacheManagerIsUpToDate();
// Ensure settings are initialized correctly.
InitializeUserSettings();
}
protected override void Initialize()
{
Trace.WriteLine(String.Format(CultureInfo.CurrentCulture, "Entering Initialize() of: {0}", this.ToString()));
base.Initialize();
try
{
errorList = new VSTools.ErrorList.Pane(this);
Log._.Received -= onLogReceived;
Log._.Received += onLogReceived;
initAppEvents();
OleMenuCommandService mcs = (OleMenuCommandService)GetService(typeof(IMenuCommandService));
// Build / <Main App>
_menuItemMain = new MenuCommand(_menuMainCallback, new CommandID(GuidList.MAIN_CMD_SET, (int)PkgCmdIDList.CMD_MAIN));
_menuItemMain.Visible = false;
mcs.AddCommand(_menuItemMain);
// View / Other Windows / <Status Panel>
mcs.AddCommand(new MenuCommand(_menuPanelCallback, new CommandID(GuidList.PANEL_CMD_SET, (int)PkgCmdIDList.CMD_PANEL)));
// To listen events that fired as a IVsSolutionEvents
spSolution = (IVsSolution)ServiceProvider.GlobalProvider.GetService(typeof(SVsSolution));
spSolution.AdviseSolutionEvents(this, out _pdwCookieSolution);
// To listen events that fired as a IVsUpdateSolutionEvents2
spSolutionBM = (IVsSolutionBuildManager2)ServiceProvider.GlobalProvider.GetService(typeof(SVsSolutionBuildManager));
spSolutionBM.AdviseUpdateSolutionEvents(this, out _pdwCookieSolutionBM);
}
catch (Exception ex)
{
string msg = string.Format("{0}\n{1}\n\n-----\n{2}",
"Something went wrong -_-",
"Try to restart IDE or reinstall current plugin in Extension Manager.",
ex.ToString());
Debug.WriteLine(msg);
int res;
Guid id = Guid.Empty;
IVsUIShell uiShell = (IVsUIShell)GetService(typeof(SVsUIShell));
Microsoft.VisualStudio.ErrorHandler.ThrowOnFailure(
uiShell.ShowMessageBox(
0,
ref id,
"Initialize vsSolutionBuildEvent",
msg,
string.Empty,
0,
OLEMSGBUTTON.OLEMSGBUTTON_OK,
OLEMSGDEFBUTTON.OLEMSGDEFBUTTON_FIRST,
OLEMSGICON.OLEMSGICON_WARNING,
0,
out res));
}
}
/// <summary>
/// Constructor.
/// Register Solution events.
/// </summary>
public SolutionChangeEventListener() {
InitNullEvents();
solution = Package.GetGlobalService(typeof(SVsSolution)) as IVsSolution;
if(solution != null) {
solution.AdviseSolutionEvents(this, out solutionEventsCookie);
}
}
private void AdviceSolutionEvents()
{
solution = Package.GetGlobalService(typeof(SVsSolution)) as IVsSolution;
if (solution != null)
{
ErrorHandler.ThrowOnFailure(solution.AdviseSolutionEvents(this, out solutionCookie));
}
}
public SolutionEventsListener(IServiceProvider serviceProvider)
{
solution = serviceProvider.GetService(typeof(SVsSolution)) as IVsSolution;
if (solution != null)
{
solution.AdviseSolutionEvents(this, out solutionEventsCookie);
}
}
private void AdviceSolutionEvents()
{
solution = Package.GetGlobalService(typeof(SVsSolution)) as IVsSolution;
if (solution != null)
{
ErrorHandler.ThrowOnFailure(solution.AdviseSolutionEvents(this, out solutionCookie));
}
}
public SolutionEvents(TestServices testServices, IVsSolution solution)
{
testServices.ThrowIfNotOnMainThread();
_joinableTaskFactory = testServices.JoinableTaskFactory;
_solution = solution;
ErrorHandler.ThrowOnFailure(solution.AdviseSolutionEvents(this, out _cookie));
}
public SolutionEventSinks()
{
solution = (IVsSolution)Package.GetGlobalService(typeof(SVsSolution));
if (null == solution)
Trace.WriteLine("Can't access solution service");
else
solution.AdviseSolutionEvents((IVsSolutionEvents)this, out solutionEventsCookie);
}
public SolutionEventListener([Import(typeof (SVsServiceProvider))] IServiceProvider serviceProvider)
{
ValidateArg.NotNull(serviceProvider, "serviceProvider");
_solution = (IVsSolution) serviceProvider.GetService(typeof (IVsSolution));
if (_solution != null)
{
_solution.AdviseSolutionEvents(this, out _solutionEventsCookie);
}
}
public SolutionEvent(ServiceProvider sp)
{
serviceProvider = sp;
solution = (IVsSolution)Microsoft.VisualStudio.Shell.Package.GetGlobalService(typeof(IVsSolution));
dte = (EnvDTE.DTE)Microsoft.VisualStudio.Shell.Package.GetGlobalService(typeof(EnvDTE.DTE));
//serviceProvider.GetService(typeof(SVsSolution)) as IVsSolution;
if (solution != null)
{
solution.AdviseSolutionEvents(this, out solutionEventsCookie);
}
}
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;
}
}
public SolutionService(IServiceProvider serviceProvider, SourceControlProvider sourceControlProvider)
{
_serviceProvider = serviceProvider;
_vsSolution = serviceProvider.GetService<SVsSolution, IVsSolution>();
_isRefreshEnabled = true;
sourceControlProvider.Activated += (sender, e) =>
{
string directory, fileName, userFile;
_vsSolution.GetSolutionInfo(out directory, out fileName, out userFile);
_vsSolution.AdviseSolutionEvents(this, out _cookieSolutionEvents);
if (string.IsNullOrEmpty(directory))
_repositoryService.CloseRepository();
else
_repositoryService.OpenRepositoryAt(directory);
};
sourceControlProvider.Deactivated += (sender, e) =>
{
StopListeningToSolutionEvents();
_repositoryService.CloseRepository();
};
}
/// <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()
{
UnityRefactorHelperSettingsCommand.Initialize(this);
base.Initialize();
Cache.Instance.OleMenuCommandService = GetService(typeof (IMenuCommandService)) as OleMenuCommandService;
Cache.Instance.Dte = (DTE) GetService(typeof (SDTE));
var events = Cache.Instance.Dte.Events;
_documentEvents = events.DocumentEvents;
_buildEvents = events.BuildEvents;
Cache.Instance.SolutionService = GetService(typeof (IVsSolution)) as IVsSolution;
_solutionEvents = new SolutionEvents();
_solution = GetService(typeof (SVsSolution)) as IVsSolution;
_solution.AdviseSolutionEvents(_solutionEvents, out _solutionEventsCookie);
_documentEvents.DocumentSaved += DocumentEventsOnDocumentSaved;
_buildEvents.OnBuildProjConfigDone += BuildEventsOnOnBuildProjConfigDone;
}
/// <summary>
/// Initialization of the package; this method is called right after the package is sited, so this is the place
/// where you can put all the initialization code that rely on services provided by VisualStudio.
/// </summary>
protected override void Initialize()
{
Debug.WriteLine("Entering Initialize() of: {0}", ToString());
base.Initialize();
_vsSolution = (IVsSolution) GetService(typeof (SVsSolution));
_vsSolution.AdviseSolutionEvents(this, out _cookie);
}
protected override void Initialize()
{
Trace.WriteLine(String.Format(CultureInfo.CurrentCulture, "Entering Initialize() of: {0}", ToString()));
base.Initialize();
try
{
errorList = new VSTools.ErrorList.Pane(this);
Log._.Received -= onLogReceived;
Log._.Received += onLogReceived;
OleMenuCommandService mcs = (OleMenuCommandService)GetService(typeof(IMenuCommandService));
// Top Menu
_menuItemMain = new MenuCommand(_menuMainCallback, new CommandID(GuidList.CMD_MAIN, PkgCmdIDList.CMD_MAIN));
_menuItemMain.Visible = false;
mcs.AddCommand(_menuItemMain);
mcs.AddCommand(
new MenuCommand(
_menuCfgUnwarnCallback,
new CommandID(GuidList.CMD_MAIN, PkgCmdIDList.CMD_UNWARN)
)
);
// To listen events that fired as a IVsSolutionEvents
spSolution = (IVsSolution)ServiceProvider.GlobalProvider.GetService(typeof(SVsSolution));
spSolution.AdviseSolutionEvents(this, out _pdwCookieSolution);
initAppEvents();
}
catch(Exception ex)
{
string msg = string.Format("{0}\n{1}\n\n-----\n{2}",
"Something went wrong -_-",
"Try to restart IDE or reinstall current plugin in Extension Manager.",
ex.ToString());
Debug.WriteLine(msg);
int res;
Guid id = Guid.Empty;
IVsUIShell uiShell = (IVsUIShell)GetService(typeof(SVsUIShell));
Microsoft.VisualStudio.ErrorHandler.ThrowOnFailure(
uiShell.ShowMessageBox(
0,
ref id,
"Initialize vsCommandEvent",
msg,
string.Empty,
0,
OLEMSGBUTTON.OLEMSGBUTTON_OK,
OLEMSGDEFBUTTON.OLEMSGDEFBUTTON_FIRST,
OLEMSGICON.OLEMSGICON_WARNING,
0,
out res));
}
}
protected override void Initialize()
{
Common.Trace("Package intialize");
base.Initialize();
Common.Trace("Task manager.Initialize()");
// Initialize common functionality
Common.Initialize(this);
taskListMenu = new RootMenu();
// Initialize fields
tools = new Tools();
sharedTaskManagers = new List<TaskManager>();
// Attach to solution events
solution = GetService(typeof(SVsSolution)) as IVsSolution;
if (solution == null) Common.Log("Could not get solution");
solution.AdviseSolutionEvents(this as IVsSolutionEvents, out solutionEventsCookie);
// Attach to build events
buildManager = GetService(typeof(SVsSolutionBuildManager)) as IVsSolutionBuildManager;
if (buildManager == null) Common.Log("Could not get build manager");
buildManager.AdviseUpdateSolutionEvents(this, out buildManagerCookie);
// Add a TaskManagerFactory service
ITaskManagerFactory factory = this as ITaskManagerFactory;
(this as System.ComponentModel.Design.IServiceContainer).AddService(typeof(ITaskManagerFactory), factory, true);
// Set PID for msbuild tasks
Environment.SetEnvironmentVariable( "VSPID", System.Diagnostics.Process.GetCurrentProcess().Id.ToString() );
}
/// <summary>
/// Defines listeners for main events.
/// </summary>
private void adviseEvents()
{
// To listen events that fired as a IVsSolutionEvents
spSolution = (IVsSolution)ServiceProvider.GlobalProvider.GetService(typeof(SVsSolution));
spSolution.AdviseSolutionEvents(this, out _pdwCookieSolution);
// To listen events that fired as a IVsUpdateSolutionEvents2
spSolutionBM = (IVsSolutionBuildManager2)ServiceProvider.GlobalProvider.GetService(typeof(SVsSolutionBuildManager));
spSolutionBM.AdviseUpdateSolutionEvents(this, out _pdwCookieSolutionBM);
}
public SolutionEventsSink(IMessageBus messageBus, IVsSolution solution)
{
_messageBus = messageBus;
_solution = solution;
solution.AdviseSolutionEvents(this, out _cookie);
}
protected override void Initialize()
{
base.Initialize();
// Initialize common functionality
Common.Initialize(this);
taskListMenu = new RootMenu();
// Initialize fields
tools = new Tools();
sharedTaskManagers = new List<TaskManager>();
// Attach to solution events
solution = GetService(typeof(SVsSolution)) as IVsSolution;
// if (solution == null) throw new NullReferenceException();
solution.AdviseSolutionEvents(this as IVsSolutionEvents, out solutionEventsCookie);
// Attach to build events
buildManager = GetService(typeof(SVsSolutionBuildManager)) as IVsSolutionBuildManager;
// if (buildManager == null) throw new NullReferenceException();
buildManager.AdviseUpdateSolutionEvents(this, out buildManagerCookie);
// Add a TaskManagerFactory service
(this as System.ComponentModel.Design.IServiceContainer).AddService(typeof(ITaskManagerFactory), this, true);
}
partial void AdviseSolutionEvents()
{
solution = (IVsSolution)GetService(typeof(SVsSolution));
solution.AdviseSolutionEvents(this, out solutionEventsCookie);
}
public SolutionAdvisor(IVsSolution solution)
{
ErrorHandler.ThrowOnFailure(solution.AdviseSolutionEvents(this, out _cookie));
}
public AzureSolutionListener(IServiceProvider serviceProvider) {
_serviceProvider = serviceProvider;
_solution = _serviceProvider.GetService(typeof(SVsSolution)) as IVsSolution;
ErrorHandler.ThrowOnFailure(_solution.AdviseSolutionEvents(this, out _eventsCookie));
}
/////////////////////////////////////////////////////////////////////////////
// Overridden Package Implementation
/// <summary>
/// Initialization of the package; this method is called right after the package is sited, so this is the place
/// where you can put all the initialization code that rely on services provided by VisualStudio.
/// </summary>
protected override void Initialize()
{
Debug.WriteLine(string.Format(CultureInfo.CurrentCulture, "Entering Initialize() of: {0}", this.ToString()));
base.Initialize();
// listen for solution events
_solution = (IVsSolution)GetService(typeof(SVsSolution));
ErrorHandler.ThrowOnFailure(_solution.AdviseSolutionEvents(this, out _solutionCookie));
_dte = (DTE)GetService(typeof(SDTE));
var events = _dte.Events;
_buildEvents = events.BuildEvents;
if (_errorListProvider == null)
_errorListProvider = new ErrorListProvider(this);
Dispatcher.CurrentDispatcher.BeginInvoke(new Action(() =>
{
Options = (ShowMissingOptions)GetDialogPage(typeof(ShowMissingOptions));
}), DispatcherPriority.ApplicationIdle, null);
_buildEvents.OnBuildProjConfigBegin += BuildEventsOnOnBuildProjConfigBegin;
_buildEvents.OnBuildBegin += BuildEventsOnOnBuildBegin;
_buildEvents.OnBuildDone += BuildEventsOnOnBuildDone;
}
protected override void Initialize()
{
Trace.WriteLine(String.Format(CultureInfo.CurrentCulture, "Entering Initialize() of: {0}", this.ToString()));
base.Initialize();
try
{
initAppEvents();
OleMenuCommandService mcs = (OleMenuCommandService)GetService(typeof(IMenuCommandService));
// Build / <Main App>
_menuItemMain = new MenuCommand(_menuMainCallback, new CommandID(GuidList.MAIN_CMD_SET, (int)PkgCmdIDList.CMD_MAIN));
_menuItemMain.Visible = false;
mcs.AddCommand(_menuItemMain);
// View / Other Windows / <Status Panel>
mcs.AddCommand(new MenuCommand(_menuPanelCallback, new CommandID(GuidList.PANEL_CMD_SET, (int)PkgCmdIDList.CMD_PANEL)));
// To listen events that fired as a IVsSolutionEvents
spSolution = (IVsSolution)ServiceProvider.GlobalProvider.GetService(typeof(SVsSolution));
spSolution.AdviseSolutionEvents(this, out _pdwCookieSolution);
// To listen events that fired as a IVsUpdateSolutionEvents2
spSolutionBM = (IVsSolutionBuildManager2)ServiceProvider.GlobalProvider.GetService(typeof(SVsSolutionBuildManager));
spSolutionBM.AdviseUpdateSolutionEvents(this, out _pdwCookieSolutionBM);
}
catch(Exception ex)
{
string msg = string.Format("{0}\n{1}\n\n-----\n{2}",
"Something went wrong -_-",
"Try to restart IDE or reinstall current plugin in Extension Manager.",
ex.ToString());
Log.Fatal(msg);
int res;
Guid id = Guid.Empty;
IVsUIShell uiShell = (IVsUIShell)GetService(typeof(SVsUIShell));
Microsoft.VisualStudio.ErrorHandler.ThrowOnFailure(
uiShell.ShowMessageBox(
0,
ref id,
"Initialize vsSolutionBuildEvent",
msg,
string.Empty,
0,
OLEMSGBUTTON.OLEMSGBUTTON_OK,
OLEMSGDEFBUTTON.OLEMSGDEFBUTTON_FIRST,
OLEMSGICON.OLEMSGICON_WARNING,
0,
out res));
}
}
protected override void Initialize()
{
base.Initialize();
AddMenuCommands();
_solution = GetService(typeof (SVsSolution)) as IVsSolution;
if (_solution != null)
_solution.AdviseSolutionEvents(this, out _dwCookie);
var dte = (DTE)GetService(typeof(DTE));
var itemOperations = new ItemOperationsWrapper(dte);
var solutionFolderWrapper = new SolutionFolderWrapper(dte);
var defaultDocumentPolicy = new DefaultDocumentPolicy();
var server = new WebServer();
_impl = new WelcomePageImpl(solutionFolderWrapper, defaultDocumentPolicy, itemOperations, server);
}
public TeamPilgrimVsService(TeamPilgrimPackage packageInstance, IVsUIShell vsUiShell, DTE2 dte2, IVsSolution vsSolution)
{
_teamFoundationBuild = new Lazy<VsTeamFoundationBuildWrapper>(() => new VsTeamFoundationBuildWrapper(_packageInstance.GetPackageService<IVsTeamFoundationBuild>()));
_portalSettingsLauncher = new Lazy<IPortalSettingsLauncher>(() => _packageInstance.GetPackageService<IPortalSettingsLauncher>());
_sourceControlSettingsLauncher = new Lazy<ISourceControlSettingsLauncher>(() => _packageInstance.GetPackageService<ISourceControlSettingsLauncher>());
_processTemplateManagerLauncher = new Lazy<IProcessTemplateManagerLauncher>(() => _packageInstance.GetPackageService<IProcessTemplateManagerLauncher>());
_workItemTrackingPackage = new Lazy<WorkItemTrackingPackageWrapper>();
_versionControlPackage = new Lazy<VersionControlPackageWrapper>();
_querySecurityCommandHelpers = new Lazy<QuerySecurityCommandHelpersWrapper>();
_pendingChangesPageViewModelUtilsWrapper = new Lazy<PendingChangesPageViewModelUtilsWrapper>();
VsUiShell = vsUiShell;
_packageInstance = packageInstance;
Dte2 = dte2;
VsSolution = vsSolution;
VersionControlExt = dte2.GetObject("Microsoft.VisualStudio.TeamFoundation.VersionControl.VersionControlExt") as VersionControlExt;
TeamFoundationServerExt = dte2.GetObject("Microsoft.VisualStudio.TeamFoundation.TeamFoundationServerExt") as TeamFoundationServerExt;
WorkItemTrackingDocumentService = new DocumentServiceWrapper(dte2.GetObject("Microsoft.VisualStudio.TeamFoundation.WorkItemTracking.DocumentService") as DocumentService);
var teamFoundationHostObject = (ITeamFoundationContextManager)TeamFoundationServerExt_TeamFoundationHostField.Value.GetValue(TeamFoundationServerExt);
TeamFoundationHost = new TeamFoundationHostWrapper(teamFoundationHostObject);
vsSolution.AdviseSolutionEvents(this, out _adviseSolutionEventsCookie);
}
/// <summary>
/// Initialization of the package; this method is called right after the package is sited, so this is the place
/// where you can put all the initialization code that rely on services provided by VisualStudio.
/// </summary>
protected override void Initialize()
{
Debug.WriteLine(string.Format(CultureInfo.CurrentCulture, "Entering Initialize() of: {0}", this.ToString()));
base.Initialize();
//// Add our command handlers for menu (commands must exist in the .vsct file)
OleMenuCommandService mcs = GetService(typeof(IMenuCommandService)) as OleMenuCommandService;
if (null != mcs)
{
CommandID slncmd = new CommandID(GuidList.guidNuSightCmdSet, (int)PkgCmdIDList.cmdBindSymbol);
MenuCommand mBind = new MenuCommand(BindSymbols, slncmd);
mcs.AddCommand(mBind);
CommandID vslcmd = new CommandID(GuidList.guidNuSightCmdSet, (int)PkgCmdIDList.cmdVisualize);
MenuCommand mVisual = new MenuCommand(Visualize, vslcmd);
mcs.AddCommand(mVisual);
}
_solution = ServiceProvider.GlobalProvider.GetService(typeof(SVsSolution)) as IVsSolution2;
if (_solution != null)
{
// Register for solution events
_solution.AdviseSolutionEvents(this, out _solutionEventsCookie);
}
}
protected override void Initialize()
{
RegisterProjectFactory(new MonoTouch26FlavorProjectFactory(this));
RegisterProjectFactory(new MonoTouch28FlavorProjectFactory(this));
_dte = GetService(typeof(SDTE)) as DTE;
if (_dte == null) throw new Exception("DTE Reference Not Found");
_buildEvents = _dte.Events.BuildEvents;
_buildEvents.OnBuildBegin += MakeXibsNone;
_buildEvents.OnBuildDone += MakeXibsPage;
_solution = (IVsSolution)GetService(typeof(SVsSolution));
if (_solution == null) throw new Exception("IVSSolution Reference Not Found.");
_solution.AdviseSolutionEvents(_solutionEvents, out _solutionEventsCookie);
base.Initialize();
}
