public void SetSite() { // Create the package IVsPackage package = new SccProvider() as IVsPackage; Assert.IsNotNull(package, "The object does not implement IVsPackage"); // Create a basic service provider OleServiceProvider serviceProvider = OleServiceProvider.CreateOleServiceProviderWithBasicServices(); // Need to mock a service implementing IVsRegisterScciProvider, because the scc provider will register with it IVsRegisterScciProvider registerScciProvider = MockRegisterScciProvider.GetBaseRegisterScciProvider(); serviceProvider.AddService(typeof(IVsRegisterScciProvider), registerScciProvider, true); // Register solution events because the provider will try to subscribe to them MockSolution solution = new MockSolution(); serviceProvider.AddService(typeof(SVsSolution), solution as IVsSolution, true); // Register TPD service because the provider will try to subscribe to TPD IVsTrackProjectDocuments2 tpd = MockTrackProjectDocumentsProvider.GetTrackProjectDocuments() as IVsTrackProjectDocuments2; serviceProvider.AddService(typeof(SVsTrackProjectDocuments), tpd, true); // Site the package Assert.AreEqual(0, package.SetSite(serviceProvider), "SetSite did not return S_OK"); // Unsite the package Assert.AreEqual(0, package.SetSite(null), "SetSite(null) did not return S_OK"); }
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(); }
public int OnAfterOpenSolution([In] Object pUnkReserved, [In] int fNewSolution) { ThreadHelper.JoinableTaskFactory.Run(async delegate { await OpenTracker(); }); //RefreshDelay = InitialRefreshDelay; //automatic switch the scc provider if (!Active && !GitSccOptions.Current.DisableAutoLoad) { ThreadHelper.JoinableTaskFactory.Run(async delegate { await OpenTracker(); }); if (RepositoryManager.Instance.GetRepositories().Count > 0) { ThreadHelper.ThrowIfNotOnUIThread(); IVsRegisterScciProvider rscp = (IVsRegisterScciProvider)_sccProvider.GetService(typeof(IVsRegisterScciProvider)); rscp.RegisterSourceControlProvider(GuidList.guidSccProvider); } } return(VSConstants.S_OK); }
/// <summary> /// Called when the package is loaded, performs package initialization tasks such as registering the source control provider /// </summary> protected override void Initialize() { base.Initialize(); // Proffer the source control service implemented by the provider sccService = new SccProviderService(this); ((IServiceContainer)this).AddService(typeof(SccProviderService), sccService, true); // Add our command handlers for menu (commands must exist in the .vsct file) MsVsShell.OleMenuCommandService mcs = GetService(typeof(IMenuCommandService)) as MsVsShell.OleMenuCommandService; if (mcs != null) { CommandID cmd = new CommandID(GuidList.guidSccProviderCmdSet, CommandId.icmdSccCommand); MenuCommand menuCmd = new MenuCommand(new EventHandler(OnSccCommand), cmd); mcs.AddCommand(menuCmd); // ToolWindow Command cmd = new CommandID(GuidList.guidSccProviderCmdSet, CommandId.icmdViewToolWindow); menuCmd = new MenuCommand(new EventHandler(ViewToolWindow), cmd); mcs.AddCommand(menuCmd); // ToolWindow's ToolBar Command cmd = new CommandID(GuidList.guidSccProviderCmdSet, CommandId.icmdToolWindowToolbarCommand); menuCmd = new MenuCommand(new EventHandler(ToolWindowToolbarCommand), cmd); mcs.AddCommand(menuCmd); } // Register the provider with the source control manager // If the package is to become active, this will also callback on OnActiveStateChange and the menu commands will be enabled IVsRegisterScciProvider rscp = (IVsRegisterScciProvider)GetService(typeof(IVsRegisterScciProvider)); rscp.RegisterSourceControlProvider(GuidList.guidSccProvider); }
public void TestSccComand() { // Create the package BasicSccProvider package = new BasicSccProvider(); // Create a basic service provider OleServiceProvider serviceProvider = OleServiceProvider.CreateOleServiceProviderWithBasicServices(); // Need to mock a service implementing IVsRegisterScciProvider, because the scc provider will register with it IVsRegisterScciProvider registerScciProvider = MockRegisterScciProvider.GetBaseRegisterScciProvider(); serviceProvider.AddService(typeof(IVsRegisterScciProvider), registerScciProvider, true); // Site the package Assert.AreEqual(0, ((IVsPackage)package).SetSite(serviceProvider), "SetSite did not return S_OK"); // Test the scc command by toggleing it twice MethodInfo method = typeof(BasicSccProvider).GetMethod("OnSccCommand", BindingFlags.NonPublic | BindingFlags.Instance); TestSccCommand commandWell = new TestSccCommand(); CommandID cmdID = new CommandID(new System.Guid(), 0); MenuCommand command = new MenuCommand(new EventHandler(commandWell.OnSccCommand), cmdID); object result = method.Invoke(package, new object[] { command, null }); Assert.AreEqual(true, command.Checked, "OnSccCommand did not execute correctly"); result = method.Invoke(package, new object[] { command, null }); Assert.AreEqual(false, command.Checked, "OnSccCommand did not execute correctly"); }
/// <summary> /// Return a IVsRegisterScciProvider without any special implementation /// </summary> /// <returns></returns> internal static IVsRegisterScciProvider GetBaseRegisterScciProvider() { if (registerScciProviderFactory == null) { registerScciProviderFactory = new GenericMockFactory("RegisterScciProvider", new Type[] { typeof(IVsRegisterScciProvider) }); } IVsRegisterScciProvider registerProvider = (IVsRegisterScciProvider)registerScciProviderFactory.GetInstance(); return(registerProvider); }
public void RegisterAsPrimarySccProvider() { IVsRegisterScciProvider rscp = GetService <IVsRegisterScciProvider>(); if (rscp == null) { return; } VSErr.ThrowOnFailure(rscp.RegisterSourceControlProvider(ProviderGuid)); }
public int OnAfterOpenSolution([InAttribute] Object pUnkReserved, [InAttribute] int fNewSolution) { //automatic switch the scc provider if (!Active && !GitSccOptions.Current.DisableAutoLoad) { OpenTracker(); if (trackers.Count > 0) { IVsRegisterScciProvider rscp = (IVsRegisterScciProvider)_sccProvider.GetService(typeof(IVsRegisterScciProvider)); rscp.RegisterSourceControlProvider(GuidList.guidSccProvider); } } Refresh(); return(VSConstants.S_OK); }
public void UseToolWindow() { // Create the package SccProvider package = new SccProvider(); // Create a basic service provider OleServiceProvider serviceProvider = OleServiceProvider.CreateOleServiceProviderWithBasicServices(); // Need to mock a service implementing IVsRegisterScciProvider, because the scc provider will register with it IVsRegisterScciProvider registerScciProvider = MockRegisterScciProvider.GetBaseRegisterScciProvider(); serviceProvider.AddService(typeof(IVsRegisterScciProvider), registerScciProvider, true); // Add site support to create and enumerate tool windows BaseMock uiShell = MockUiShellProvider.GetWindowEnumerator0(); serviceProvider.AddService(typeof(SVsUIShell), uiShell, false); // Register solution events because the provider will try to subscribe to them MockSolution solution = new MockSolution(); serviceProvider.AddService(typeof(SVsSolution), solution as IVsSolution, true); // Register TPD service because the provider will try to subscribe to TPD IVsTrackProjectDocuments2 tpd = MockTrackProjectDocumentsProvider.GetTrackProjectDocuments() as IVsTrackProjectDocuments2; serviceProvider.AddService(typeof(SVsTrackProjectDocuments), tpd, true); // Site the package Assert.AreEqual(0, ((IVsPackage)package).SetSite(serviceProvider), "SetSite did not return S_OK"); // Test that toolwindow can be created MethodInfo method = typeof(SccProvider).GetMethod("Exec_icmdViewToolWindow", BindingFlags.NonPublic | BindingFlags.Instance); object result = method.Invoke(package, new object[] { null, null }); // Test that toolwindow toolbar's command can be executed method = typeof(SccProvider).GetMethod("Exec_icmdToolWindowToolbarCommand", BindingFlags.NonPublic | BindingFlags.Instance); result = method.Invoke(package, new object[] { null, null }); // Toggle the toolwindow color back method = typeof(SccProvider).GetMethod("Exec_icmdToolWindowToolbarCommand", BindingFlags.NonPublic | BindingFlags.Instance); result = method.Invoke(package, new object[] { null, null }); // Get the window and test the dispose function SccProviderToolWindow window = (SccProviderToolWindow)package.FindToolWindow(typeof(SccProviderToolWindow), 0, true); method = typeof(SccProviderToolWindow).GetMethod("Dispose", BindingFlags.NonPublic | BindingFlags.Instance); result = method.Invoke(window, new object[] { true }); }
//-------------------------------------------------------------------------------- // IVsSolutionEvents and IVsSolutionEvents2 specific functions //-------------------------------------------------------------------------------- #region IVsSolutionEvents interface functions public int OnAfterOpenSolution([InAttribute] Object pUnkReserved, [InAttribute] int fNewSolution) { Trace.WriteLine("OnAfterOpenSolution"); // Make VisualHG the active SCC controler on Mercurial solution types if (!Active && Configuration.Global._autoActivatePlugin) { string root = this._sccProvider.GetRootDirectory(); if (root.Length > 0) { IVsRegisterScciProvider rscp = (IVsRegisterScciProvider)this._sccProvider.GetService(typeof(IVsRegisterScciProvider)); rscp.RegisterSourceControlProvider(GuidList.guidSccProvider); } } return(VSConstants.S_OK); }
public Task <CodeContainer> AcquireCodeContainerAsync(IProgress <ServiceProgressData> downloadProgress, CancellationToken cancellationToken) { if (ExecuteCommand("File.Perforce.P4VS.Open_Solution_in_Perforce_Depot")) { downloadProgress.Report(new ServiceProgressData(string.Empty, string.Empty, 1, 1)); return(null); } else { try { IVsRegisterScciProvider registerSccProvider = ServiceProvider.GlobalProvider.GetService(typeof(IVsRegisterScciProvider)) as IVsRegisterScciProvider; if (registerSccProvider == null) { return(null); } // Try to activate the Scc provider int hr = registerSccProvider.RegisterSourceControlProvider(GuidList.guidP4VsProvider); if (ErrorHandler.Failed(hr)) { return(null); } } catch (Exception ex) { System.Windows.Forms.MessageBox.Show(ex.Message); } if (ExecuteCommand("File.Perforce.P4VS.Open_Solution_in_Perforce_Depot")) { downloadProgress.Report(new ServiceProgressData(string.Empty, string.Empty, 1, 1)); return(null); } } System.Windows.Forms.MessageBox.Show(Resources.StartPagePluginRegError); return(null); }
protected override void Initialize() { base.Initialize(); _CurrentSolutionRcsType = RcsType.Unknown; IVsExtensibility extensibility = GetService <IVsExtensibility>(); _DTE2 = (DTE2)extensibility.GetGlobalsObject(null).DTE; IVsSolution solution = GetService <SVsSolution>() as IVsSolution; int hr; uint pdwCookie; hr = solution.AdviseSolutionEvents(this, out pdwCookie); Marshal.ThrowExceptionForHR(hr); _VsShell = GetService <SVsShell>() as IVsShell; _VsRegisterScciProvider = GetService <IVsRegisterScciProvider>(); _SettingsStore = GetWritableSettingsStore(); }
// IVsPersistSolutionProps::ReadSolutionProps public int ReadSolutionProps([In] IVsHierarchy pHierarchy, [In] string pszProjectName, [In] string pszProjectMk, [In] string pszKey, [In] int fPreLoad, [In] IPropertyBag pPropBag) { // This function gets called by the shell when a solution controlled by this provider is opened in IDE. // The shell encounters the _strSolutionPersistanceKey section in the solution, and based based on // registration info written by ProvideSolutionProps identifies this package as the section owner, // loads this package if necessary and calls the package to read the persisted solution options. logger.Debug("P4VS Startup in ReadSolutionProps"); SolutionFileTagged = false; if (_strSolutionPersistanceKey.CompareTo(pszKey) == 0) { SolutionFileTagged = true; // We were called to read the key written by this source control provider // First thing to do: register the source control provider with the source control manager. // This allows the scc manager to switch the active source control provider if necessary, // and set this provider active; the provider will be later called to provide source control services // for this solution. // (This is how automatic source control provider switching on solution opening is implemented) IVsRegisterScciProvider rscp = (IVsRegisterScciProvider)GetService(typeof(IVsRegisterScciProvider)); rscp.RegisterSourceControlProvider(GuidList.guidP4VsProvider); // Now we can read all the data and store it in memory // The read data will be used when the solution has completed opening object pVar; pPropBag.Read(_strSolutionControlledProperty, out pVar, null, 0, null); if (pVar.ToString().CompareTo(true.ToString()) == 0) { try { SccService.LoadingControlledSolutionLocation = pVar.ToString(); } catch { } } } return(VSConstants.S_OK); }
protected override void Initialize() { Trace.WriteLine(String.Format(CultureInfo.CurrentUICulture, "Entering Initialize() of: {0}", this.ToString())); base.Initialize(); // Proffer the source control service implemented by the provider sccService = new SccProviderService(this); ((IServiceContainer)this).AddService(typeof(SccProviderService), sccService, true); ((IServiceContainer)this).AddService(typeof(System.IServiceProvider), this, true); // Add our command handlers for menu (commands must exist in the .vsct file) InitVSCTMenuCommandHandler(); // Register the provider with the source control manager // If the package is to become active, this will also callback on OnActiveStateChange and the menu commands will be enabled IVsRegisterScciProvider rscp = (IVsRegisterScciProvider)GetService(typeof(IVsRegisterScciProvider)); rscp.RegisterSourceControlProvider(GuidList.guidSccProvider); _OnIdleEvent.RegisterForIdleTimeCallbacks(GetGlobalService(typeof(SOleComponentManager)) as IOleComponentManager); _OnIdleEvent.OnIdleEvent += new OnIdleEvent(sccService.UpdateDirtyNodesGlyphs); //ShowToolWindow(VisualHGToolWindow.PendingChanges); }
public void SetSite() { // Create the package IVsPackage package = new BasicSccProvider() as IVsPackage; Assert.IsNotNull(package, "The object does not implement IVsPackage"); // Create a basic service provider OleServiceProvider serviceProvider = OleServiceProvider.CreateOleServiceProviderWithBasicServices(); // Need to mock a service implementing IVsRegisterScciProvider, because the scc provider will register with it IVsRegisterScciProvider registerScciProvider = MockRegisterScciProvider.GetBaseRegisterScciProvider(); serviceProvider.AddService(typeof(IVsRegisterScciProvider), registerScciProvider, true); // Site the package Assert.AreEqual(0, package.SetSite(serviceProvider), "SetSite did not return S_OK"); // Unsite the package Assert.AreEqual(0, package.SetSite(null), "SetSite(null) did not return S_OK"); // Remove the mock service serviceProvider.RemoveService(typeof(IVsRegisterScciProvider)); }
protected override void Initialize() { try { // load the local settings Preferences.Initialize(); Preferences.LocalSettings.Load(null); logger.Trace("Entering Initialize() of: {0}", this.ToString()); base.Initialize(); // Proffer the source control service implemented by the provider // The service provider implemented by the package SccService = new P4VsProviderService(this); ((IServiceContainer)this).AddService(typeof(P4VsProviderService), SccService, true); // Initilise Glyphs IVsHierarchy solHier = (IVsHierarchy)GetService(typeof(SVsSolution)); Glyphs = new NodeGlyphs(SccService, solHier); // Add our command handlers for menu (commands must exist in the .vsct file) OleMenuCommandService mcs = GetService(typeof(IMenuCommandService)) as OleMenuCommandService; if (mcs != null) { // View Menu commands #region View Menu commands // Workspaces ToolWindow Command CommandID cmd = new CommandID(GuidList.guidP4VsProviderCmdSet, CommandId.icmdViewWorkspaceToolWindow); MenuCommand menuCmd = new MenuCommand(new EventHandler(P4VsViewWorkspaceToolWindow), cmd); mcs.AddCommand(menuCmd); // History ToolWindow cmd = new CommandID(GuidList.guidP4VsProviderCmdSet, CommandId.icmdViewHistoryToolWindow); menuCmd = new MenuCommand(new EventHandler(P4VsViewHistoryToolWindow), cmd); mcs.AddCommand(menuCmd); // Jobs ToolWindow cmd = new CommandID(GuidList.guidP4VsProviderCmdSet, CommandId.icmdViewJobsToolWindow); menuCmd = new MenuCommand(new EventHandler(P4VsViewJobsToolWindow), cmd); mcs.AddCommand(menuCmd); // P4 ToolWindow //cmd = new CommandID(GuidList.guidP4VsProviderCmdSet, CommandId.icmdViewP4ToolWindow); //menuCmd = new MenuCommand(new EventHandler(P4VsViewP4ToolWindow), cmd); //mcs.AddCommand(menuCmd); // SubmittedChangelists ToolWindow cmd = new CommandID(GuidList.guidP4VsProviderCmdSet, CommandId.icmdViewSubmittedChangelistsToolWindow); menuCmd = new MenuCommand(new EventHandler(P4VsViewSubmittedChangelistsToolWindow), cmd); mcs.AddCommand(menuCmd); // PendingChangelists ToolWindow cmd = new CommandID(GuidList.guidP4VsProviderCmdSet, CommandId.icmdViewPendingChangelistsToolWindow); menuCmd = new MenuCommand(new EventHandler(P4VsViewPendingChangelistsToolWindow), cmd); mcs.AddCommand(menuCmd); // Labels ToolWindow cmd = new CommandID(GuidList.guidP4VsProviderCmdSet, CommandId.icmdViewLabelsToolWindow); menuCmd = new MenuCommand(new EventHandler(P4VsViewLabelsToolWindow), cmd); mcs.AddCommand(menuCmd); // Swarm ToolWindow //cmd = new CommandID(GuidList.guidP4VsProviderCmdSet, CommandId.icmdViewSwarmToolWindow); //menuCmd = new MenuCommand(new EventHandler(P4VsViewSwarmToolWindow), cmd); //mcs.AddCommand(menuCmd); // Streams ToolWindow cmd = new CommandID(GuidList.guidP4VsProviderCmdSet, CommandId.icmdViewStreamsToolWindow); menuCmd = new MenuCommand(new EventHandler(P4VsViewStreamsToolWindow), cmd); mcs.AddCommand(menuCmd); // Reviews ToolWindow //cmd = new CommandID(GuidList.guidP4VsProviderCmdSet, CommandId.icmdViewReviewsToolWindow); //menuCmd = new MenuCommand(new EventHandler(P4VsViewReviewsToolWindow), cmd); //mcs.AddCommand(menuCmd); #endregion // Help Menu commands #region Help Menu commands // Help/P4VS Help cmd = new CommandID(GuidList.guidP4VsProviderCmdSet, CommandId.icmdP4VSHelp); menuCmd = new MenuCommand(new EventHandler(P4VsP4VSHelp), cmd); mcs.AddCommand(menuCmd); // Help/P4VS SystemInfo cmd = new CommandID(GuidList.guidP4VsProviderCmdSet, CommandId.icmdP4VSSystemInfo); menuCmd = new MenuCommand(new EventHandler(P4VsP4VSSystemInfo), cmd); mcs.AddCommand(menuCmd); #endregion // File Menu commands #region File Menu commands // File/Open Solution in Perforce Depot cmd = new CommandID(GuidList.guidP4VsProviderCmdSet, CommandId.icmdFileOpenInDepot); menuCmd = new MenuCommand(new EventHandler(P4VsFileOpenInDepot), cmd); mcs.AddCommand(menuCmd); // File/Open Connection to a Perforce Depot cmd = new CommandID(GuidList.guidP4VsProviderCmdSet, CommandId.icmdOpenConnection); menuCmd = new MenuCommand(new EventHandler(P4VsOpenConnection), cmd); mcs.AddCommand(menuCmd); // File/Close Connection to the Perforce Depot cmd = new CommandID(GuidList.guidP4VsProviderCmdSet, CommandId.icmdCloseConnection); menuCmd = new MenuCommand(new EventHandler(P4VsCloseConnection), cmd); mcs.AddCommand(menuCmd); // Workspaces ToolWindow's ToolBar Command //cmd = new CommandID(GuidList.guidP4VsProviderCmdSet, CommandId.icmdToolWindowToolbarCommand); //menuCmd = new MenuCommand(new EventHandler(P4VsWorkspaceToolWindowToolbarCommand), cmd); //mcs.AddCommand(menuCmd); #endregion // Source control menu commands #region File Menu commands cmd = new CommandID(GuidList.guidP4VsProviderCmdSet, CommandId.icmdScmRefresh); menuCmd = new MenuCommand(new EventHandler(P4VsScmRefresh), cmd); mcs.AddCommand(menuCmd); cmd = new CommandID(GuidList.guidP4VsProviderCmdSet, CommandId.icmdAddToSourceControl); menuCmd = new MenuCommand(new EventHandler(P4VsAddToSourceControl), cmd); mcs.AddCommand(menuCmd); cmd = new CommandID(GuidList.guidP4VsProviderCmdSet, CommandId.icmdCheckin); menuCmd = new MenuCommand(new EventHandler(P4VsCheckin), cmd); mcs.AddCommand(menuCmd); //cmd = new CommandID(GuidList.guidP4VsProviderCmdSet, CommandId.icmdCheckout); //menuCmd = new MenuCommand(new EventHandler(P4VsCheckout), cmd); //mcs.AddCommand(menuCmd); cmd = new CommandID(GuidList.guidP4VsProviderCmdSet, CommandId.icmdCheckout); menuCmd = new OleMenuCommand(new EventHandler(P4VsCheckout), cmd); //queryStatusMenuCommand.BeforeQueryStatus +=new EventHandler(OnBeforeQueryStatus); mcs.AddCommand(menuCmd); cmd = new CommandID(GuidList.guidP4VsProviderCmdSet, CommandId.icmdCheckoutProject); menuCmd = new MenuCommand(new EventHandler(P4VsCheckoutEntireProjectOrSolution), cmd); mcs.AddCommand(menuCmd); cmd = new CommandID(GuidList.guidP4VsProviderCmdSet, CommandId.icmdCheckoutSolution); menuCmd = new MenuCommand(new EventHandler(P4VsCheckoutEntireProjectOrSolution), cmd); mcs.AddCommand(menuCmd); //cmd = new CommandID(GuidList.guidP4VsProviderCmdSet, CommandId.icmdUseSccOffline); //menuCmd = new MenuCommand(new EventHandler(P4VsUseSccOffline), cmd); //mcs.AddCommand(menuCmd); cmd = new CommandID(GuidList.guidP4VsProviderCmdSet, CommandId.icmdReconcile); menuCmd = new MenuCommand(new EventHandler(P4VsReconcileFiles), cmd); mcs.AddCommand(menuCmd); cmd = new CommandID(GuidList.guidP4VsProviderCmdSet, CommandId.icmdRevert); menuCmd = new MenuCommand(new EventHandler(P4VsRevert), cmd); mcs.AddCommand(menuCmd); cmd = new CommandID(GuidList.guidP4VsProviderCmdSet, CommandId.icmdRevertUnchanged); menuCmd = new MenuCommand(new EventHandler(P4VsRevertUnchanged), cmd); mcs.AddCommand(menuCmd); cmd = new CommandID(GuidList.guidP4VsProviderCmdSet, CommandId.icmdLock); menuCmd = new MenuCommand(new EventHandler(P4VsLock), cmd); mcs.AddCommand(menuCmd); cmd = new CommandID(GuidList.guidP4VsProviderCmdSet, CommandId.icmdUnlock); menuCmd = new MenuCommand(new EventHandler(P4VsUnlock), cmd); mcs.AddCommand(menuCmd); cmd = new CommandID(GuidList.guidP4VsProviderCmdSet, CommandId.icmdChangeFileType); menuCmd = new MenuCommand(new EventHandler(P4VsChangeFileType), cmd); mcs.AddCommand(menuCmd); cmd = new CommandID(GuidList.guidP4VsProviderCmdSet, CommandId.icmdMoveToChangelist); menuCmd = new MenuCommand(new EventHandler(P4VsMoveToChangelist), cmd); mcs.AddCommand(menuCmd); cmd = new CommandID(GuidList.guidP4VsProviderCmdSet, CommandId.icmdAddToIgnoreList); menuCmd = new MenuCommand(new EventHandler(P4VsAddToIgnoreList), cmd); mcs.AddCommand(menuCmd); cmd = new CommandID(GuidList.guidP4VsProviderCmdSet, CommandId.icmdRemoveFromIgnoreList); menuCmd = new MenuCommand(new EventHandler(P4VsRemoveFromIgnoreList), cmd); mcs.AddCommand(menuCmd); cmd = new CommandID(GuidList.guidP4VsProviderCmdSet, CommandId.icmdEditIgnoreList); menuCmd = new MenuCommand(new EventHandler(P4VsEditIgnoreList), cmd); mcs.AddCommand(menuCmd); cmd = new CommandID(GuidList.guidP4VsProviderCmdSet, CommandId.icmdResolve); menuCmd = new MenuCommand(new EventHandler(P4VsResolve), cmd); mcs.AddCommand(menuCmd); cmd = new CommandID(GuidList.guidP4VsProviderCmdSet, CommandId.icmdSync); menuCmd = new MenuCommand(new EventHandler(P4VsSync), cmd); mcs.AddCommand(menuCmd); cmd = new CommandID(GuidList.guidP4VsProviderCmdSet, CommandId.icmdSyncHead); menuCmd = new MenuCommand(new EventHandler(P4VsSyncHead), cmd); mcs.AddCommand(menuCmd); cmd = new CommandID(GuidList.guidP4VsProviderCmdSet, CommandId.icmdDiffVsHave); menuCmd = new MenuCommand(new EventHandler(P4VsDiffVsHave), cmd); mcs.AddCommand(menuCmd); cmd = new CommandID(GuidList.guidP4VsProviderCmdSet, CommandId.icmdDiffVsAny); menuCmd = new MenuCommand(new EventHandler(P4VsDiffVsAny), cmd); mcs.AddCommand(menuCmd); //cmd = new CommandID(GuidList.guidP4VsProviderCmdSet, CommandId.icmdAddProjectToSCC); //menuCmd = new MenuCommand(new EventHandler(P4VsAddProjectToSCC), cmd); //mcs.AddCommand(menuCmd); cmd = new CommandID(GuidList.guidP4VsProviderCmdSet, CommandId.icmdShowHistory); menuCmd = new MenuCommand(new EventHandler(P4VsShowHistory), cmd); mcs.AddCommand(menuCmd); cmd = new CommandID(GuidList.guidP4VsProviderCmdSet, CommandId.icmdShelve); menuCmd = new MenuCommand(new EventHandler(P4VsShelve), cmd); mcs.AddCommand(menuCmd); //cmd = new CommandID(GuidList.guidP4VsProviderCmdSet, CommandId.icmdScmAttributes); //menuCmd = new MenuCommand(new EventHandler(P4VsScmAttributes), cmd); //mcs.AddCommand(menuCmd); cmd = new CommandID(GuidList.guidP4VsProviderCmdSet, CommandId.icmdScmMerge); menuCmd = new MenuCommand(new EventHandler(P4VsScmMerge), cmd); mcs.AddCommand(menuCmd); cmd = new CommandID(GuidList.guidP4VsProviderCmdSet, CommandId.icmdScmCopy); menuCmd = new MenuCommand(new EventHandler(P4VsScmCopy), cmd); mcs.AddCommand(menuCmd); #endregion // P4V commands #region P4V Menu commands cmd = new CommandID(GuidList.guidP4VsProviderCmdSet, CommandId.icmdP4V); menuCmd = new MenuCommand(new EventHandler(P4VsP4V), cmd); mcs.AddCommand(menuCmd); cmd = new CommandID(GuidList.guidP4VsProviderCmdSet, CommandId.icmdTimeLapse); menuCmd = new MenuCommand(new EventHandler(P4VsTimeLapse), cmd); mcs.AddCommand(menuCmd); cmd = new CommandID(GuidList.guidP4VsProviderCmdSet, CommandId.icmdRevGraph); menuCmd = new MenuCommand(new EventHandler(P4VsRevGraph), cmd); mcs.AddCommand(menuCmd); cmd = new CommandID(GuidList.guidP4VsProviderCmdSet, CommandId.icmdStreamGraph); menuCmd = new MenuCommand(new EventHandler(P4VsStreamGraph), cmd); mcs.AddCommand(menuCmd); cmd = new CommandID(GuidList.guidP4VsProviderCmdSet, CommandId.cmdidCancelActiveCommand); menuCmd = new MenuCommand(new EventHandler(Exec_CancelActiveCommand), cmd); mcs.AddCommand(menuCmd); cmd = new CommandID(GuidList.guidP4VsProviderCmdSet, CommandId.cmdidCurrentStream); menuCmd = new MenuCommand(new EventHandler(Exec_CurrentStream), cmd); mcs.AddCommand(menuCmd); #endregion // Status Bar commands #region Status Bar commands // Add to Source Control/Publish cmd = new CommandID(GuidList.guidP4VsProviderCmdSet, CommandId.icmdPublish); menuCmd = new MenuCommand(new EventHandler(P4VsScmPublish), cmd); mcs.AddCommand(menuCmd); #endregion // DropDownCombo // a DROPDOWNCOMBO does not let the user type into the combo box; they can only pick from the list. // The string value of the element selected is returned. // For example, this type of combo could be used for the "Solution Configurations" on the "Standard" toolbar. // // A DropDownCombo box requires two commands: // One command (cmdidMyCombo) is used to ask for the current value of the combo box and to // set the new value when the user makes a choice in the combo box. // // The second command (cmdidMyComboGetList) is used to retrieve this list of choices for the combo box. // // Normally IOleCommandTarget::QueryStatus is used to determine the state of a command, e.g. // enable vs. disable, shown vs. hidden, etc. The QueryStatus method does not have any way to // control the statue of a combo box, e.g. what list of items should be shown and what is the // current value. In order to communicate this information actually IOleCommandTarget::Exec // is used with a non-NULL varOut parameter. You can think of these Exec calls as extended // QueryStatus calls. There are two pieces of information needed for a combo, thus it takes // two commands to retrieve this information. The main command id for the command is used to // retrieve the current value and the second command is used to retrieve the full list of // choices to be displayed as an array of strings. cmd = new CommandID(GuidList.guidP4VsProviderCmdSet, (int)CommandId.cmdidConnectionDropDownCombo); omcConnectionComboSelChanged = new OleMenuCommand(new EventHandler(P4VsConnectionDropDownCombo), cmd); omcConnectionComboSelChanged.ParametersDescription = "$"; // accept any argument string mcs.AddCommand(omcConnectionComboSelChanged); cmd = new CommandID(GuidList.guidP4VsProviderCmdSet, (int)CommandId.cmdidConnectionDropDownComboGetList); omcConnectionComboGetList = new OleMenuCommand(new EventHandler(P4VsConnectionDropDownComboGetList), cmd); mcs.AddCommand(omcConnectionComboGetList); cmd = new CommandID(GuidList.guidP4VsProviderCmdSet, (int)CommandId.cmdidActiveChangelistDropDownCombo); omcActiveChangelistComboSelChanged = new OleMenuCommand(new EventHandler(P4VsActiveChangelistDropDownCombo), cmd); omcActiveChangelistComboSelChanged.ParametersDescription = "$"; // accept any argument string mcs.AddCommand(omcActiveChangelistComboSelChanged); cmd = new CommandID(GuidList.guidP4VsProviderCmdSet, (int)CommandId.cmdidActiveChangelistDropDownComboGetList); omcActiveChangelistComboGetList = new OleMenuCommand(new EventHandler(P4VsActiveChangelistDropDownComboGetList), cmd); mcs.AddCommand(omcActiveChangelistComboGetList); } // -- Set an eventlistener for shell property changes var shellService = GetService(typeof(SVsShell)) as IVsShell; if (shellService != null) { ErrorHandler.ThrowOnFailure(shellService.AdviseShellPropertyChanges(this, out _EventSinkCookie)); } // Register the provider with the source control manager // If the package is to become active, this will also callback on OnActiveStateChange and the menu commands will be enabled IVsRegisterScciProvider rscp = (IVsRegisterScciProvider)GetService(typeof(IVsRegisterScciProvider)); rscp.RegisterSourceControlProvider(GuidList.guidP4VsProvider); instance = this; } catch (Exception ex) { logger.Error(ex, "Initialize failed"); logger.Error("Error: {0}", ex.Message); logger.Error("Stacktrace: {0}", ex.StackTrace); } }
///////////////////////////////////////////////////////////////////////////// // BasicSccProvider Package Implementation #region Package Members protected override void Initialize() { Trace.WriteLine(String.Format(CultureInfo.CurrentUICulture, "Entering Initialize() of: {0}", this.ToString())); base.Initialize(); projects = new List <GitFileStatusTracker>(); sccService = new SccProviderService(this, projects); ((IServiceContainer)this).AddService(typeof(SccProviderService), sccService, true); Blinkbox.Events.BlinkboxSccHooks.TriggerOnPackageInitialise(this, new Blinkbox.Events.OnPackageInitialiseArgs() { PackageInstance = this, SccService = this.sccService }); // Add our command handlers for menu (commands must exist in the .vsct file) MsVsShell.OleMenuCommandService mcs = GetService(typeof(IMenuCommandService)) as MsVsShell.OleMenuCommandService; if (mcs != null) { CommandID cmd = new CommandID(GuidList.guidSccProviderCmdSet, CommandId.icmdSccCommandRefresh); var menu = new MenuCommand(new EventHandler(OnRefreshCommand), cmd); mcs.AddCommand(menu); cmd = new CommandID(GuidList.guidSccProviderCmdSet, CommandId.icmdSccCommandGitBash); menu = new MenuCommand(new EventHandler(OnGitBashCommand), cmd); mcs.AddCommand(menu); cmd = new CommandID(GuidList.guidSccProviderCmdSet, CommandId.icmdSccCommandGitExtension); menu = new MenuCommand(new EventHandler(OnGitExtensionCommand), cmd); mcs.AddCommand(menu); cmd = new CommandID(GuidList.guidSccProviderCmdSet, CommandId.icmdSccCommandCompare); menu = new MenuCommand(new EventHandler(OnCompareCommand), cmd); mcs.AddCommand(menu); cmd = new CommandID(GuidList.guidSccProviderCmdSet, CommandId.icmdSccCommandUndo); menu = new MenuCommand(new EventHandler(OnUndoCommand), cmd); mcs.AddCommand(menu); cmd = new CommandID(GuidList.guidSccProviderCmdSet, CommandId.icmdSccCommandInit); menu = new MenuCommand(new EventHandler(OnInitCommand), cmd); mcs.AddCommand(menu); cmd = new CommandID(GuidList.guidSccProviderCmdSet, CommandId.icmdSccCommandEditIgnore); menu = new MenuCommand(new EventHandler(OnEditIgnore), cmd); mcs.AddCommand(menu); cmd = new CommandID(GuidList.guidSccProviderCmdSet, CommandId.icmdSccCommandGitTortoise); menu = new MenuCommand(new EventHandler(OnTortoiseGitCommand), cmd); mcs.AddCommand(menu); for (int i = 0; i < GitToolCommands.GitExtCommands.Count; i++) { cmd = new CommandID(GuidList.guidSccProviderCmdSet, CommandId.icmdGitExtCommand1 + i); var mc = new MenuCommand(new EventHandler(OnGitExtCommandExec), cmd); mcs.AddCommand(mc); } for (int i = 0; i < GitToolCommands.GitTorCommands.Count; i++) { cmd = new CommandID(GuidList.guidSccProviderCmdSet, CommandId.icmdGitTorCommand1 + i); var mc = new MenuCommand(new EventHandler(OnGitTorCommandExec), cmd); mcs.AddCommand(mc); } cmd = new CommandID(GuidList.guidSccProviderCmdSet, CommandId.icmdSccCommandPendingChanges); menu = new MenuCommand(new EventHandler(ShowPendingChangesWindow), cmd); mcs.AddCommand(menu); cmd = new CommandID(GuidList.guidSccProviderCmdSet, CommandId.icmdSccCommandHistory); menu = new MenuCommand(new EventHandler(ShowHistoryWindow), cmd); mcs.AddCommand(menu); cmd = new CommandID(GuidList.guidSccProviderCmdSet, CommandId.icmdPendingChangesCommitToBranch); menu = new MenuCommand(new EventHandler(OnSwitchBranchCommand), cmd); mcs.AddCommand(menu); cmd = new CommandID(GuidList.guidSccProviderCmdSet, CommandId.icmdPendingChangesCommit); menu = new MenuCommand(new EventHandler(OnCommitCommand), cmd); mcs.AddCommand(menu); cmd = new CommandID(GuidList.guidSccProviderCmdSet, CommandId.icmdPendingChangesAmend); menu = new MenuCommand(new EventHandler(OnAmendCommitCommand), cmd); mcs.AddCommand(menu); cmd = new CommandID(GuidList.guidSccProviderCmdSet, CommandId.icmdSccCommandAbout); menu = new MenuCommand(new EventHandler(OnAbout), cmd); mcs.AddCommand(menu); Blinkbox.Events.BlinkboxSccHooks.TriggerRegisterCommands(this, new Blinkbox.Events.OnRegisterCommandsArgs() { MenuService = mcs }); } // Register the provider with the source control manager // If the package is to become active, this will also callback on OnActiveStateChange and the menu commands will be enabled IVsRegisterScciProvider rscp = (IVsRegisterScciProvider)GetService(typeof(IVsRegisterScciProvider)); rscp.RegisterSourceControlProvider(GuidList.guidSccProvider); _OnIdleEvent.RegisterForIdleTimeCallbacks(GetGlobalService(typeof(SOleComponentManager)) as IOleComponentManager); _OnIdleEvent.OnIdleEvent += new OnIdleEvent(sccService.UpdateNodesGlyphs); }
///////////////////////////////////////////////////////////////////////////// // BasicSccProvider Package Implementation #region Package Members protected override async Task InitializeAsync(System.Threading.CancellationToken cancellationToken, IProgress <ServiceProgressData> progress) { Trace.WriteLine(String.Format(CultureInfo.CurrentUICulture, "Entering Initialize() of: {0}", this.ToString())); GitBash.GitExePath = GitSccOptions.Current.GitBashPath; GitBash.UseUTF8FileNames = !GitSccOptions.Current.NotUseUTF8FileNames; //base.Initialize(); await base.InitializeAsync(cancellationToken, progress); //projects = new List<GitFileStatusTracker>(); this.AddService(typeof(SccProviderService), CreateGitService, true); await JoinableTaskFactory.SwitchToMainThreadAsync(cancellationToken); // Add our command handlers for menu (commands must exist in the .vsct file) MsVsShell.OleMenuCommandService mcs = await GetServiceAsync(typeof(IMenuCommandService)) as MsVsShell.OleMenuCommandService; if (mcs != null) { CommandID cmd = new CommandID(GuidList.guidSccProviderCmdSet, CommandId.icmdSccCommandRefresh); var menu = new MenuCommand(new EventHandler(OnRefreshCommand), cmd); mcs.AddCommand(menu); cmd = new CommandID(GuidList.guidSccProviderCmdSet, CommandId.icmdSccCommandGitBash); menu = new MenuCommand(new EventHandler(OnGitBashCommand), cmd); mcs.AddCommand(menu); cmd = new CommandID(GuidList.guidSccProviderCmdSet, CommandId.icmdSccCommandGitExtension); menu = new MenuCommand(new EventHandler(OnGitExtensionCommand), cmd); mcs.AddCommand(menu); cmd = new CommandID(GuidList.guidSccProviderCmdSet, CommandId.icmdSccCommandCompare); menu = new MenuCommand(new EventHandler(OnCompareCommand), cmd); mcs.AddCommand(menu); cmd = new CommandID(GuidList.guidSccProviderCmdSet, CommandId.icmdSccCommandUndo); menu = new MenuCommand(new EventHandler(OnUndoCommand), cmd); mcs.AddCommand(menu); cmd = new CommandID(GuidList.guidSccProviderCmdSet, CommandId.icmdSccCommandInit); menu = new MenuCommand(new EventHandler(OnInitCommand), cmd); mcs.AddCommand(menu); cmd = new CommandID(GuidList.guidSccProviderCmdSet, CommandId.icmdSccCommandEditIgnore); menu = new MenuCommand(new EventHandler(OnEditIgnore), cmd); mcs.AddCommand(menu); cmd = new CommandID(GuidList.guidSccProviderCmdSet, CommandId.cmdidGitIgnoreSubMenuCommandUpdate); menu = new MenuCommand(new EventHandler(OnEditUpdate), cmd); mcs.AddCommand(menu); cmd = new CommandID(GuidList.guidSccProviderCmdSet, CommandId.icmdSccCommandGitTortoise); menu = new MenuCommand(new EventHandler(OnTortoiseGitCommand), cmd); mcs.AddCommand(menu); for (int i = 0; i < GitToolCommands.GitExtCommands.Count; i++) { cmd = new CommandID(GuidList.guidSccProviderCmdSet, CommandId.icmdGitExtCommand1 + i); var mc = new MenuCommand(new EventHandler(OnGitExtCommandExec), cmd); mcs.AddCommand(mc); } for (int i = 0; i < GitToolCommands.GitTorCommands.Count; i++) { cmd = new CommandID(GuidList.guidSccProviderCmdSet, CommandId.icmdGitTorCommand1 + i); var mc = new MenuCommand(new EventHandler(OnGitTorCommandExec), cmd); mcs.AddCommand(mc); } cmd = new CommandID(GuidList.guidSccProviderCmdSet, CommandId.icmdSccCommandPendingChanges); menu = new MenuCommand(new EventHandler(ShowPendingChangesWindow), cmd); mcs.AddCommand(menu); cmd = new CommandID(GuidList.guidSccProviderCmdSet, CommandId.icmdSccCommandHistory); menu = new MenuCommand(new EventHandler(ShowHistoryWindow), cmd); mcs.AddCommand(menu); cmd = new CommandID(GuidList.guidSccProviderCmdSet, CommandId.icmdPendingChangesCommitToBranch); menu = new MenuCommand(new EventHandler(OnSwitchBranchCommand), cmd); mcs.AddCommand(menu); cmd = new CommandID(GuidList.guidSccProviderCmdSet, CommandId.icmdPendingChangesCommit); menu = new MenuCommand(new EventHandler(OnCommitCommand), cmd); mcs.AddCommand(menu); cmd = new CommandID(GuidList.guidSccProviderCmdSet, CommandId.icmdPendingChangesAmend); menu = new MenuCommand(new EventHandler(OnAmendCommitCommand), cmd); mcs.AddCommand(menu); cmd = new CommandID(GuidList.guidSccProviderCmdSet, CommandId.icmdPendingChangesSettings); menu = new MenuCommand(new EventHandler(OnSettings), cmd); mcs.AddCommand(menu); cmd = new CommandID(GuidList.guidSccProviderCmdSet, PackageIds.cmdIdAddProjectToSCC); menu = new MenuCommand(new EventHandler(OnAddProjectToSCC), cmd); mcs.AddCommand(menu); } ThreadHelper.ThrowIfNotOnUIThread(); // Register the provider with the source control manager // If the package is to become active, this will also callback on OnActiveStateChange and the menu commands will be enabled IVsRegisterScciProvider rscp = await GetServiceAsync(typeof(IVsRegisterScciProvider)) as IVsRegisterScciProvider; rscp.RegisterSourceControlProvider(GuidList.guidSccProvider); _OnIdleEvent.RegisterForIdleTimeCallbacks(GetGlobalService(typeof(SOleComponentManager)) as IOleComponentManager); //_OnIdleEvent.OnIdleEvent += new OnIdleEvent(sccService.UpdateNodesGlyphs); SetupStatusMenu(); }