C# OleMenuCommandService.AddCommand方法代码示例

        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 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);
        }

        /// <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 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 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 );
 }

        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);
        }

        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);
        }

        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 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);
 }

        private void InstallMenu(OleMenuCommandService mcs)
        {
            if (mcs != null)
            {
                var debugLocally = new CommandID(PackageGuids.guidMonoDebugger_VS2013CmdSet, (int)PackageIds.cmdLocalDebugCode);
                var localCmd = new OleMenuCommand(DebugLocalClicked, debugLocally);
                localCmd.BeforeQueryStatus += cmd_BeforeQueryStatus;
                mcs.AddCommand(localCmd);


                var menuCommandID = new CommandID(PackageGuids.guidMonoDebugger_VS2013CmdSet,
                    (int)PackageIds.cmdRemodeDebugCode);
                var cmd = new OleMenuCommand(DebugRemoteClicked, menuCommandID);
                cmd.BeforeQueryStatus += cmd_BeforeQueryStatus;
                mcs.AddCommand(cmd);

                var cmdOpenLogFileId = new CommandID(PackageGuids.guidMonoDebugger_VS2013CmdSet,
                    (int)PackageIds.cmdOpenLogFile);
                var openCmd = new OleMenuCommand(OpenLogFile, cmdOpenLogFileId);
                openCmd.BeforeQueryStatus += (o, e) => openCmd.Enabled = File.Exists(MonoLogger.LoggerPath);
                mcs.AddCommand(openCmd);
            }
        }

    ////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
    ////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
    ////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////

    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);
        }
      }
    }

        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);
            }
        }