public Commands(IVsExtensionRepository repo, IVsExtensionManager manager, OleMenuCommandService mcs, IVsOutputWindowPane outputPane) { _repository = repo; _manager = manager; _mcs = mcs; _outputPane = outputPane; }
public void SetupCommands(OleMenuCommandService commandService) { if (Package.DocumentManager == null) { return; } var guid = typeof(RestoreTabsListCommandIds).GUID; var commandId = new CommandID(guid, (int)RestoreTabsListCommandIds.RestoreTabsListPlaceholder); var command = new OleMenuCommand(null, commandId); command.BeforeQueryStatus += RestoreTabsListPlaceholderCommandOnBeforeQueryStatus; commandService.AddCommand(command); for (var i = (int)RestoreTabsListCommandIds.RestoreTabsListStart; i <= (int)RestoreTabsListCommandIds.RestoreTabsListEnd; i++) { commandId = new CommandID(guid, i); command = new OleMenuCommand(ExecuteRestoreTabsCommand, commandId); command.BeforeQueryStatus += RestoreTabsCommandOnBeforeQueryStatus; commandService.AddCommand(command); var index = GetGroupIndex(command); Package.Environment.SetKeyBindings(command, $"Global::Ctrl+D,{index}", $"Text Editor::Ctrl+D,{index}"); } }
private void CreateToolWindows(OleMenuCommandService mcs) { WindowLauncher launcher = new WindowLauncher(this); CommandID toolwndCommandID = new CommandID(GuidList.guidLonestarCmdSet, (int)PkgCmdIDList.resultsWindow); MenuCommand menuToolWin = new MenuCommand(launcher.ShowToolWindow, toolwndCommandID); mcs.AddCommand( menuToolWin ); }
public ProjectSettingsMenu(DTE2 dte, OleMenuCommandService mcs) { _dte = dte; _mcs = mcs; _dte.Events.SolutionEvents.Opened += SolutionEvents_Opened; }
public CSharpResetInteractiveMenuCommand( OleMenuCommandService menuCommandService, IVsMonitorSelection monitorSelection, IComponentModel componentModel) : base(ContentTypeNames.CSharpContentType, menuCommandService, monitorSelection, componentModel) { }
public void RegisterTo(OleMenuCommandService menuCommandService, SpecFlowCmdSet commandId) { CommandID menuCommandID = new CommandID(GuidList.guidSpecFlowCmdSet, (int)(uint)commandId); OleMenuCommand menuItem = new OleMenuCommand(InvokeHandler, menuCommandID); menuItem.BeforeQueryStatus += BeforeQueryStatusHandler; menuCommandService.AddCommand(menuItem); }
private void AddAttachToCommand(OleMenuCommandService mcs, uint commandId, Func<GeneralOptionsPage, bool> isVisible, params string[] programsToAttach) { var menuItemCommand = new OleMenuCommand((sender, args) => Attach(programsToAttach), new CommandID(GuidList.guidAttachToCmdSet, (int)commandId)); menuItemCommand.BeforeQueryStatus += (s, e) => menuItemCommand.Visible = isVisible((GeneralOptionsPage)GetDialogPage(typeof(GeneralOptionsPage))); mcs.AddCommand(menuItemCommand); }
private ClearCache(OleMenuCommandService commandService, AsyncPackage package) { ServiceProvider = package; var commandID = new CommandID(PackageGuids.guidClearCachePackageCmdSet, PackageIds.ClearCacheId); var button = new MenuCommand(DeleteCacheFolder, commandID); commandService.AddCommand(button); }
public HubsT4Menu(DTE2 dte, OleMenuCommandService mcs) { _dte = dte; _mcs = mcs; _dependencies = new List<string>(); _dependencies.Add(@"\typings\jquery\jquery.d.ts"); _dependencies.Add(@"\typings\signalr\signalr.d.ts"); }
//Todo: See if this can be refactored with better IoC private void SetDependencies() { var dte = ((DTE)GetService(typeof(DTE))); var solution = dte != null ? dte.Solution : null; _commandService = (OleMenuCommandService) GetService(typeof (IMenuCommandService)); _tortoiseGitLauncherService = (ITortoiseGitLauncherService) GetService(typeof (TortoiseGitLauncherService)) ?? new TortoiseGitLauncherService(new ProcessManagerService(), solution); }
EnableReloadCommand(Package package, OleMenuCommandService commandService) { _package = package; var id = new CommandID(PackageGuids.guidBrowserReloadCmdSet, PackageIds.EnableReloadCommandId); var cmd = new OleMenuCommand(Execute, id); cmd.BeforeQueryStatus += BeforeQueryStatus; commandService.AddCommand(cmd); }
public MarkdownMenu(DTE2 dte, OleMenuCommandService mcs) { Mef.SatisfyImportsOnce(this); _contentType = ContentTypes.GetContentType("Markdown"); _extensions = FileExtensionRegistry.GetFileExtensionSet(_contentType); _dte = dte; _mcs = mcs; }
private AddCommand(OleMenuCommandService commandService, DTE2 dte) { _dte = dte; var cmdAddCommand = new CommandID(PackageGuids.guidCommandCmdSet, PackageIds.AddCommandId); var addCommandItem = new OleMenuCommand(AddCommandToFile, cmdAddCommand); addCommandItem.BeforeQueryStatus += BeforeQueryStatus; commandService.AddCommand(addCommandItem); }
/// <summary> /// Add buttons to the toolbar. Specify the target toolbar, which button to place, and /// the corresponding function call. /// </summary> private void AddCommand(OleMenuCommandService mcs, int cmdid, EventHandler handler) { // Create the command for the tool window CommandID commandID = new CommandID(GuidList.guidCommandTargetRGBCmdSet, cmdid); OleMenuCommand command = new OleMenuCommand(handler, commandID); command.BeforeQueryStatus += OnBeforeQueryStatus; mcs.AddCommand(command); }
private void AddMenuCommandHandlers() { _mcs = GetService(typeof(IMenuCommandService)) as OleMenuCommandService; if (null != _mcs) { CommandID menuCommandID = new CommandID(GuidList.guidVisualStudio_MenuExtensionCmdSet, (int)PkgCmdIDList.cmdidLinkOpenRiaServicesProject); MenuCommand menuItem = new OleMenuCommand(LinkRiaProjectCallback, null, BeforeQueryStatusForAddPackageDialog, menuCommandID); _mcs.AddCommand(menuItem); } }
private void CreateMenuCommands(OleMenuCommandService mcs) { CommandID runLonestarOnActiveViewMenuCommandID = new CommandID(GuidList.guidLonestarCmdSet, (int)PkgCmdIDList.runLonestarOnActiveView); CommandID runLonestarOnSolutionMenuCommandID = new CommandID(GuidList.guidLonestarCmdSet, (int)PkgCmdIDList.runLonestarOnSolution); MenuCommandController controller = new MenuCommandController(this); MenuCommand menuItem = new MenuCommand(controller.RunLonestarOnActiveView, runLonestarOnActiveViewMenuCommandID); mcs.AddCommand(menuItem); MenuCommand runOnSolution = new MenuCommand(controller.RunLonestarOnSolution, runLonestarOnSolutionMenuCommandID); mcs.AddCommand(runOnSolution); }
public HandlebarsMenu(DTE2 dte, OleMenuCommandService mcs) { Mef.SatisfyImportsOnce(this); _contentType = ContentTypes.GetContentType("Handlebars"); if (_contentType != null) _extensions = FileExtensionRegistry.GetFileExtensionSet(_contentType); _dte = dte; _mcs = mcs; }
private void AddCommand(OleMenuCommandService mcs, uint commandId) { OleMenuCommand menuItemCommand = new OleMenuCommand( delegate(object sender, EventArgs e) { RefreshAppPoolMenu(mcs); }, new CommandID(GuidList.guidNielsV_AttachToAppPoolCmdSet, (int)commandId)); //menuItemCommand.BeforeQueryStatus += (s, e) => menuItemCommand.Visible = isVisible((GeneralOptionsPage)this.GetDialogPage(typeof(GeneralOptionsPage))); mcs.AddCommand(menuItemCommand); }
protected GitStatusBarManager(Guid commandSetGuid, int branchMenuCmId, int branchCommandMenuCmId, int repositoryCommandMenuCmId, IServiceContainer serviceProvider, IStatusBarService statusBarService) { BranchMenuCmId = branchMenuCmId; BranchCommandMenuCmId = branchCommandMenuCmId; RepositoryCommandMenuCmId = repositoryCommandMenuCmId; StatusBarService = statusBarService; CommandSetGuid = commandSetGuid; _menuCommandService = serviceProvider.GetService(typeof(IMenuCommandService)) as MsVsShell.OleMenuCommandService; _serviceProvider = serviceProvider; _branchCommandMenuCommands = new List<Tuple<string, MenuCommand>>(); }
public Plugin(DTE2 application, IVsProfferCommands3 profferCommands, ImageList icons, OleMenuCommandService oleMenuCommandService, string panelName, string connectPath, object options) { // TODO: This can be figured out from traversing the assembly and locating the Connect class... m_connectPath = connectPath; m_application = application; m_panelName = panelName; m_profferCommands = profferCommands; m_oleMenuCommandService = oleMenuCommandService; mOptions = options; m_icons = icons; }
private void SetupAttachCommand(OleMenuCommandService menuCommandService) { var dynamicItemRootId = new CommandID(GuidList.Commands, (int) CommandIDs.AttachToDynamicStub); var dynamicMenuCommand = new DynamicMenuCommand( (sender, e) => { var invokedCommand = (DynamicMenuCommand)sender; _controller.HandleAttachTo(invokedCommand.Text); }, dynamicItemRootId, index => _controller.GetTargets().ElementAtOrDefault(index) ); menuCommandService.AddCommand(dynamicMenuCommand); }
public void Install(TinyIoCContainer container) { serviceProvider = container.Resolve<IServiceProvider>(); menuCommandService = serviceProvider.GetService(typeof(IMenuCommandService)) as OleMenuCommandService; if (menuCommandService == null) return; pluginConfiguration = container.Resolve<IPluginConfiguration>(); pluginConfiguration.PropertyChanged += SetButtonState; solutionEvents = container.Resolve<ISolutionEventsListener>(); solutionEvents.AfterSolutionLoaded += SolutionLoaded; solutionEvents.BeforeSolutionClosed += SolutionClosed; var vs = container.Resolve<IVisualStudioService>(); InstallMenuCommands(vs.IsSolutionOpen); }
public void Initialize(IVsUIShell uiShell, DTE2 dte, OleMenuCommandService mcs) { if (!this.initialized) { this.UIShell = uiShell; this.DTE = dte; this.MenuCommandService = mcs; this.VSSolution = Package.GetGlobalService(typeof(SVsSolution)) as IVsSolution; InitOutputPane(); this.initialized = true; } }
//////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////// //////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////// //////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////// public void RegisterCallbacks (OleMenuCommandService menuCommandService) { if (menuCommandService != null) { foreach (KeyValuePair<uint, EventHandler> keyValue in m_eventCallbacks) { CommandID commandId = new CommandID (Guids.guidAndroidPlusPlusCommandSetID, (int)keyValue.Key); MenuCommand menuCommand = new MenuCommand (keyValue.Value, commandId); menuCommandService.AddCommand (menuCommand); } } }
/// <summary> /// Initializes a new instance of the <see cref="ZenToolsMain"/> 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 ZenToolsMain(Package package) { if (package == null) { throw new ArgumentNullException(nameof(package)); } this.package = package; commandService = this.ServiceProvider.GetService(typeof(IMenuCommandService)) as OleMenuCommandService; if (commandService != null) { CommandId = 0x0100; //CommandSet = new Guid("952f5cdf-910a-481c-801c-ba3a5e7077ba"); //GUID for menu Group // commandService.GlobalInvoke(commandID); var menuCommandID = new CommandID(CommandSet, 0x0105); var menuItem = new MenuCommand(this.ToggleBreakpoint, menuCommandID); commandService.AddCommand(menuItem); // type = typeof(Microsoft.VisualStudio.VSConstants.VSStd97CmdID); // commandID = new CommandID(type.GUID, cmdidToggleBreakpoint); // menuCommandID = new CommandID(CommandSet, CommandId); menuCommandID = new CommandID(CommandSet, 0x0101); menuItem = new MenuCommand(this.Clean, menuCommandID); commandService.AddCommand(menuItem); menuCommandID = new CommandID(CommandSet, 0x0102); menuItem = new MenuCommand(this.DisableAllBPs, menuCommandID); commandService.AddCommand(menuItem); menuCommandID = new CommandID(CommandSet, 0x0103); menuItem = new MenuCommand(this.EnableAllBPs, menuCommandID); commandService.AddCommand(menuItem); menuCommandID = new CommandID(CommandSet, 0x0104); menuItem = new MenuCommand(this.Rebuild, menuCommandID); commandService.AddCommand(menuItem); // menuCommandID = new CommandID(CommandSet, 0x0106); menuItem = new MenuCommand(this.ToggleComments, menuCommandID); commandService.AddCommand(menuItem); menuCommandID = new CommandID(CommandSet, 0x0107); menuItem = new MenuCommand(this.ViewDoc, menuCommandID); commandService.AddCommand(menuItem); } }
public void BuildMenuItems( OleMenuCommandService mcs ) { if ( OptionsPage.Attachables == null ) { Debug.WriteLine ( "ATA: No Attachables found." ); throw new ArgumentNullException ( "attachables" ); } var items = OptionsPage.Attachables.Where ( f => f.Enabled ); if ( items != null ) { var count = items.Count ( ); for ( var i = 0; i < count; ++i ) { int id = baseAttactListId + i; AddAttachCommand ( mcs, id, x => x.Attachables[i] ); } } }
public AbstractResetInteractiveMenuCommand( string contentType, OleMenuCommandService menuCommandService, IVsMonitorSelection monitorSelection, IComponentModel componentModel) { _contentType = contentType; _menuCommandService = menuCommandService; _monitorSelection = monitorSelection; _componentModel = componentModel; _resetInteractiveCommand = _componentModel.DefaultExportProvider .GetExports<IResetInteractiveCommand, ContentTypeMetadata>() .Where(resetInteractiveService => resetInteractiveService.Metadata.ContentTypes.Contains(_contentType)) .SingleOrDefault(); }
/// <summary> /// Initializes a new instance of the <see cref="GitExtCommands"/> 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 GitExtCommands(Package package) { if (package == null) { throw new ArgumentNullException("package"); } _package = package; _application = (DTE2)ServiceProvider.GetService(typeof(DTE)); _commandService = ServiceProvider.GetService(typeof(IMenuCommandService)) as OleMenuCommandService; try { //RegisterCommand("Difftool_Selection", new ToolbarCommand<OpenWithDiftool>(runForSelection: true)); RegisterCommand("Difftool", new ToolbarCommand<OpenWithDiftool>(), gitExtDiffCommand); //RegisterCommand("ShowFileHistory_Selection", new ToolbarCommand<FileHistory>(runForSelection: true)); RegisterCommand("ShowFileHistory", new ToolbarCommand<FileHistory>(), gitExtHistoryCommand); //RegisterCommand("ResetChanges_Selection", new ToolbarCommand<Revert>(runForSelection: true)); RegisterCommand("ResetChanges", new ToolbarCommand<Revert>(), gitExtResetFileCommand); RegisterCommand("Browse", new ToolbarCommand<Browse>(), gitExtBrowseCommand); RegisterCommand("Clone", new ToolbarCommand<Clone>(), gitExtCloneCommand); RegisterCommand("CreateNewRepository", new ToolbarCommand<Init>(), gitExtNewCommand); RegisterCommand("Commit", new ToolbarCommand<Commit>(), gitExtCommitCommand); RegisterCommand("Pull", new ToolbarCommand<Pull>(), gitExtPullCommand); RegisterCommand("Push", new ToolbarCommand<Push>(), gitExtPushCommand); RegisterCommand("Stash", new ToolbarCommand<Stash>(), gitExtStashCommand); RegisterCommand("Remotes", new ToolbarCommand<Remotes>(), gitExtRemotesCommand); RegisterCommand("GitIgnore", new ToolbarCommand<GitIgnore>(), gitExtGitIgnoreCommand); RegisterCommand("ApplyPatch", new ToolbarCommand<ApplyPatch>(), gitExtApplyPatchCommand); RegisterCommand("FormatPatch", new ToolbarCommand<FormatPatch>(), gitExtFormatPatchCommand); RegisterCommand("ViewChanges", new ToolbarCommand<ViewChanges>(), gitExtViewChangesCommand); RegisterCommand("FindFile", new ToolbarCommand<FindFile>(), gitExtFindFileCommand); RegisterCommand("SwitchBranch", new ToolbarCommand<SwitchBranch>(), gitExtCheckoutCommand); RegisterCommand("CreateBranch", new ToolbarCommand<CreateBranch>(), gitExtCreateBranchCommand); RegisterCommand("Merge", new ToolbarCommand<Merge>(), gitExtMergeCommand); RegisterCommand("Rebase", new ToolbarCommand<Rebase>(), gitExtRebaseCommand); RegisterCommand("SolveMergeConflicts", new ToolbarCommand<SolveMergeConflicts>(), gitExtSolveConflictsCommand); RegisterCommand("CherryPick", new ToolbarCommand<Cherry>(), gitExtCherryPickCommand); RegisterCommand("Bash", new ToolbarCommand<Bash>(), gitExtBashCommand); RegisterCommand("Settings", new ToolbarCommand<Settings>(), gitExtSettingsCommand); RegisterCommand("About", new ToolbarCommand<About>(), gitExtAboutCommand); } catch (Exception ex) { if (OutputPane != null) OutputPane.OutputString("Error adding commands: " + ex); } }
protected override void Initialize() { base.Initialize(); _statusBar = GetService(typeof (SVsStatusbar)) as IVsStatusbar; _oleMenuCommandService = GetService(typeof (IMenuCommandService)) as OleMenuCommandService; _outputWindow = GetService(typeof (SVsOutputWindow)) as IVsOutputWindow; _sortIcon = (short) Constants.SBAI_General; if (_oleMenuCommandService != null) { var menuCommandId = new CommandID(GuidList.guidErsx_Net_VsixCmdSet, (int) PkgCmdIDList.sortResx); var menuItem = new OleMenuCommand(MenuItemClick, StatusChanged, BeforeContextMenuOpens, menuCommandId); _oleMenuCommandService.AddCommand(menuItem); } }
private void AddAttachToCommand(OleMenuCommandService mcs, uint commandId, Func<GeneralOptionsPage, bool> isVisible, params string[] programsToAttach) { OleMenuCommand menuItemCommand = new OleMenuCommand( delegate(object sender, EventArgs e) { DTE dte = (DTE)this.GetService(typeof(DTE)); foreach (Process process in dte.Debugger.LocalProcesses) { if (programsToAttach.Any(p => process.Name.EndsWith(p))) { process.Attach(); } } }, new CommandID(GuidList.guidAttachToCmdSet, (int)commandId)); menuItemCommand.BeforeQueryStatus += (s, e) => menuItemCommand.Visible = isVisible((GeneralOptionsPage)this.GetDialogPage(typeof(GeneralOptionsPage))); mcs.AddCommand(menuItemCommand); }
/// <summary> /// Initializes a new instance of the <see cref="ConvertVBToCSCommand"/> class. /// Adds our command handlers for menu (commands must exist in the command table file) /// </summary> /// <param name="package">Owner package, not null.</param> /// <param name="codeConversion"></param> /// <param name="commandService"></param> /// <remarks>Must be called on the UI thread due to VS 2017's implementation of AddCommand which calls GetService</remarks> private ConvertVBToCSCommand(CodeConverterPackage package, CodeConversion codeConversion, OleMenuCommandService commandService) { ThreadHelper.ThrowIfNotOnUIThread(); this._package = package ?? throw new ArgumentNullException(nameof(package)); _codeConversion = codeConversion; if (commandService != null) { // Command in main menu var menuCommandId = new CommandID(CommandSet, MainMenuCommandId); var menuItem = package.CreateCommand(CodeEditorMenuItemCallbackAsync, menuCommandId); menuItem.BeforeQueryStatus += MainEditMenuItem_BeforeQueryStatusAsync; commandService.AddCommand(menuItem); // Command in code editor's context menu var ctxMenuCommandId = new CommandID(CommandSet, CtxMenuCommandId); var ctxMenuItem = package.CreateCommand(CodeEditorMenuItemCallbackAsync, ctxMenuCommandId); ctxMenuItem.BeforeQueryStatus += CodeEditorMenuItem_BeforeQueryStatusAsync; commandService.AddCommand(ctxMenuItem); // Command in project item context menu var projectItemCtxMenuCommandId = new CommandID(CommandSet, ProjectItemCtxMenuCommandId); var projectItemCtxMenuItem = package.CreateCommand(ProjectItemMenuItemCallbackAsync, projectItemCtxMenuCommandId); projectItemCtxMenuItem.BeforeQueryStatus += ProjectItemMenuItem_BeforeQueryStatusAsync; commandService.AddCommand(projectItemCtxMenuItem); // Command in project context menu var projectCtxMenuCommandId = new CommandID(CommandSet, ProjectCtxMenuCommandId); var projectCtxMenuItem = package.CreateCommand(SolutionOrProjectMenuItemCallbackAsync, projectCtxMenuCommandId); projectCtxMenuItem.BeforeQueryStatus += SolutionOrProjectMenuItem_BeforeQueryStatusAsync; commandService.AddCommand(projectCtxMenuItem); // Command in project context menu var solutionCtxMenuCommandId = new CommandID(CommandSet, SolutionCtxMenuCommandId); var solutionCtxMenuItem = package.CreateCommand(SolutionOrProjectMenuItemCallbackAsync, solutionCtxMenuCommandId); solutionCtxMenuItem.BeforeQueryStatus += SolutionOrProjectMenuItem_BeforeQueryStatusAsync; commandService.AddCommand(solutionCtxMenuItem); } }
///////////////////////////////////////////////////////////////////////////// // 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); ((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.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); } 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 = (IVsRegisterScciProvider)GetService(typeof(IVsRegisterScciProvider)); rscp.RegisterSourceControlProvider(GuidList.guidSccProvider); _OnIdleEvent.RegisterForIdleTimeCallbacks(GetGlobalService(typeof(SOleComponentManager)) as IOleComponentManager); //_OnIdleEvent.OnIdleEvent += new OnIdleEvent(sccService.UpdateNodesGlyphs); SetupStatusMenu(); }
/// <remarks> /// Must be called from UI thread /// </remarks> public static void Initialize(CodeConverterPackage package, OleMenuCommandService menuCommandService, CodeConversion codeConversion) { ThreadHelper.ThrowIfNotOnUIThread(); Instance = new ConvertVBToCSCommand(package, codeConversion, menuCommandService); }