public MissionScriptNode(CommandID command, int timeStamp) { z_command = command; z_timeStamp = timeStamp; z_isDone = false; z_subNodes = new List<MissionScriptNode>(); }
void CreateConfigCommand() { var configureCommandId = new CommandID(cmdSet, 1); configureCommand = new OleMenuCommand(delegate { configureMenuCallback.ConfigureCallback(); }, configureCommandId); configureCommand.BeforeQueryStatus += delegate { menuStatusChecker.ConfigureCommandStatusCheck(configureCommand); }; menuCommandService.AddCommand(configureCommand); }
void CreateDisableCommand() { var disableCommandId = new CommandID(cmdSet, 2); disableCommand = new OleMenuCommand(delegate { disableMenuConfigure.DisableCallback(); }, disableCommandId) { Enabled = false }; disableCommand.BeforeQueryStatus += delegate { menuStatusChecker.DisableCommandStatusCheck(disableCommand); }; menuCommandService.AddCommand(disableCommand); }
public void RegisterMenus() { var vsPackageCmdSet = new Guid("5ce0365b-947a-4dca-b016-ca823deaad0b"); var configureCommandId = new CommandID(vsPackageCmdSet, 1); configureCommand = new OleMenuCommand(delegate { configureMenuCallback.ConfigureCallback(); }, configureCommandId); configureCommand.BeforeQueryStatus += delegate { CommandStatusCheck(); }; menuCommandService.AddCommand(configureCommand); var disableCommandId = new CommandID(vsPackageCmdSet, 2); disableCommand = new OleMenuCommand(delegate { disableMenuConfigure.DisableCallback(); }, disableCommandId) { Enabled = false }; disableCommand.BeforeQueryStatus += delegate { CommandStatusCheck(); }; menuCommandService.AddCommand(disableCommand); }
public void RegisterMenus() { var cmdSet = new Guid("af0fbcae-2924-42bf-adb7-31202b59250a"); var configureCommandId = new CommandID(cmdSet, 1); configureCommand = new OleMenuCommand(delegate { configureMenuCallback.ConfigureCallback(); }, configureCommandId); configureCommand.BeforeQueryStatus += delegate { CommandStatusCheck(); }; menuCommandService.AddCommand(configureCommand); var disableCommandId = new CommandID(cmdSet, 2); disableCommand = new OleMenuCommand(delegate { disableMenuConfigure.DisableCallback(); }, disableCommandId) { Enabled = false }; disableCommand.BeforeQueryStatus += delegate { CommandStatusCheck(); }; menuCommandService.AddCommand(disableCommand); }
protected override void Initialize() { Debug.WriteLine(string.Format(CultureInfo.CurrentCulture, "Entering Initialize() of: {0}", this)); 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 command for the publish in crm. CommandID publishInCrmCommandID = new CommandID(GuidList.guidPublishInCrmCmdSet, (int)PkgCmdIDList.cmdidPublishInCrm); MenuCommand publishInCrmMenuItem = new MenuCommand(PublishInCrmCallback, publishInCrmCommandID); mcs.AddCommand(publishInCrmMenuItem); // Create the command for the publish in crm(solution explorer). CommandID publishInCrmMultipleCommandID = new CommandID(GuidList.guidPublishInCrmCmdSet, (int)PkgCmdIDList.cmdidPublishInCrmMultiple); MenuCommand publishInCrmMultipleMenuItem = new MenuCommand(PublishInCrmMultipleCallback, publishInCrmMultipleCommandID); mcs.AddCommand(publishInCrmMultipleMenuItem); } }
public bool QueryStatus(CommandID cmdId, CommandStatus status, CommandText text) { var des = base.GetSelectedDesigner(); if (des != null) { return(des.QueryStatus(cmdId, status, text)); } if (cmdId.Guid == CmdSets.GuidReko) { switch (cmdId.ID) { case CmdIds.CollapseAllNodes: status.Status = MenuStatus.Visible | MenuStatus.Enabled; return(true); case CmdIds.CreateUserSegment: status.Status = IsSegmentSelected() ? MenuStatus.Visible | MenuStatus.Enabled : MenuStatus.Visible; return(true); } } return(false); }
#pragma warning restore IDE0052 // Remove unread private members private IntegrationTestServiceCommands(Package package) { _package = package ?? throw new ArgumentNullException(nameof(package)); if (ServiceProvider.GetService(typeof(IMenuCommandService)) is OleMenuCommandService menuCommandService) { var startMenuCmdId = new CommandID(guidTestWindowCmdSet, cmdidStartIntegrationTestService); _startMenuCmd = new MenuCommand(StartServiceCallback, startMenuCmdId) { Enabled = true, Visible = true }; menuCommandService.AddCommand(_startMenuCmd); var stopMenuCmdId = new CommandID(guidTestWindowCmdSet, cmdidStopIntegrationTestService); _stopMenuCmd = new MenuCommand(StopServiceCallback, stopMenuCmdId) { Enabled = false, Visible = false }; menuCommandService.AddCommand(_stopMenuCmd); } }
public void LaunchCommand() { UIThreadInvoker.Invoke((ThreadInvoker) delegate() { CommandID menuItemCmd = new CommandID(AnkhId.CommandSetGuid, (int)AnkhCommand.Checkout); // Create the DialogBoxListener Thread. string expectedDialogBoxText = string.Format(CultureInfo.CurrentCulture, "{0}\n\nInside {1}.MenuItemCallback()", "AnkhSvn", "AnkhSvn.AnkhSvn.AnkhSvnPackage"); DialogBoxPurger purger = new DialogBoxPurger(NativeMethods.IDCANCEL, expectedDialogBoxText); try { purger.Start(); TestUtils testUtils = new TestUtils(); testUtils.ExecuteCommand(menuItemCmd); } finally { Assert.IsTrue(purger.WaitForDialogThreadToTerminate(), "The dialog box has not shown"); } }); }
private GoToViewCmd(Package package, DTE dte) { if (package == null) { throw new ArgumentNullException("package"); } this.package = package; OleMenuCommandService commandService = this.ServiceProvider.GetService(typeof(IMenuCommandService)) as OleMenuCommandService; if (commandService != null) { var menuCommandID = new CommandID(CommandSet, CommandId); var menuItem = new OleMenuCommand( this.MenuItemCallback, null, this.BeforeQueryStatus, menuCommandID); commandService.AddCommand(menuItem); this.dte = dte; } }
/// <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> /// <param name="cancellationToken">A cancellation token to monitor for initialization cancellation, which can occur when VS is shutting down.</param> /// <param name="progress">A provider for progress updates.</param> /// <returns>A task representing the async work of package initialization, or an already completed task if there is none. Do not return null from this method.</returns> protected override async Task InitializeAsync(CancellationToken cancellationToken, IProgress <ServiceProgressData> progress) { // When initialized asynchronously, the current thread may be a background thread at this point. // Do any initialization that requires the UI thread after switching to the UI thread. await this.JoinableTaskFactory.SwitchToMainThreadAsync(cancellationToken); if (await GetServiceAsync(typeof(IMenuCommandService)) is OleMenuCommandService mcs) { try { CommandService = await GetServiceAsync(typeof(IMenuCommandService)) as OleMenuCommandService; _dte = ServiceProvider.GlobalProvider.GetService(typeof(DTE)) as DTE2; CommandID menuCommandID = new CommandID(GuidList.guidAntDeployCmdSet, (int)PkgCmdIDList.AntDeployCommand); MenuCommand menuItem = new MenuCommand(MenuItemCallback, menuCommandID); mcs.AddCommand(menuItem); } catch (Exception e) { } } }
internal void RegisterCommands(IEnumerable <Command> commands, Guid cmdSet) { var mcs = GetService(typeof(IMenuCommandService)) as OleMenuCommandService; if (null != mcs) { lock (_commandsLock) { foreach (var command in commands) { var beforeQueryStatus = command.BeforeQueryStatus; var toolwndCommandID = new CommandID(cmdSet, command.CommandId); var menuToolWin = new OleMenuCommand(command.DoCommand, toolwndCommandID); if (beforeQueryStatus != null) { menuToolWin.BeforeQueryStatus += beforeQueryStatus; } mcs.AddCommand(menuToolWin); _commands[command] = menuToolWin; } } } }
public static async Task InitializeAsync(AsyncPackage package) { var dte = await package.GetServiceAsync(typeof(DTE)); if (dte == null) { return; } _dte2 = (DTE2)dte; if (await package.GetServiceAsync(typeof(IMenuCommandService)) is IMenuCommandService commandService) { var menuCommandID = new CommandID(CommandSet, CommandId); var menuItem = new OleMenuCommand(MenuItemCallback, menuCommandID) { // this does not work, found here https://github.com/Microsoft/VSSDK-Extensibility-Samples/blob/master/SingleFileGenerator/src/Commands/ApplyCustomTool.cs // This will defer visibility control to the VisibilityConstraints section in the .vsct file Supported = false }; commandService.AddCommand(menuItem); } }
///////////////////////////////////////////////////////////////////////////// // Overridden Package Implementation #region Package Members /// <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(); IVsUIShell uiShell = GetService <IVsUIShell, SVsUIShell>(); uiShell.EnableModeless(Convert.ToInt32(true)); // 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 command for the menu item. CommandID menuCommandId = new CommandID(GuidList.GuidResxPackageCmdSet, (int)PkgCmdIdList.ResxPackage); MenuCommand menuItem = new MenuCommand(MenuItemCallback, menuCommandId); mcs.AddCommand(menuItem); } CreateOutputWindow(); }
/// <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> /// <param name="cancellationToken">A cancellation token to monitor for initialization cancellation, which can occur when VS is shutting down.</param> /// <param name="progress">A provider for progress updates.</param> /// <returns>A task representing the async work of package initialization, or an already completed task if there is none. Do not return null from this method.</returns> protected override async Task InitializeAsync(CancellationToken cancellationToken, IProgress <ServiceProgressData> progress) { // When initialized asynchronously, the current thread may be a background thread at this point. // Do any initialization that requires the UI thread after switching to the UI thread. await this.JoinableTaskFactory.SwitchToMainThreadAsync(cancellationToken); OleMenuCommandService menuCommandService; // Add our command handlers for menu (commands must exist in the .vsct file) menuCommandService = await this.GetServiceAsync(typeof(IMenuCommandService)).ConfigureAwait(false) as OleMenuCommandService; if (menuCommandService != null) { // Create the command for the menu item. CommandID menuCommandId; MenuCommand menuItem; menuCommandId = new CommandID(GuidList.guidCyotek_AddProjectsCmdSet, (int)PkgCmdIDList.cmdidCyotekAddProjects); menuItem = new MenuCommand(this.MenuItemCallback, menuCommandId); menuCommandService.AddCommand(menuItem); } }
public static async Task InitializeAsync(AsyncPackage package) { await ThreadHelper.JoinableTaskFactory.SwitchToMainThreadAsync(package.DisposalToken); OleMenuCommandService commandService = await package.GetServiceAsync <IMenuCommandService, OleMenuCommandService>(); Assumes.Present(commandService); IVsUIShell shell = await package.GetServiceAsync <SVsUIShell, IVsUIShell>(); Assumes.Present(shell); DTE2 dte = await package.GetServiceAsync <DTE, DTE2>(); Assumes.Present(dte); var cmdId = new CommandID(PackageGuids.guidCommands, PackageIds.LanguageSetting); var menuItem = new OleMenuCommand((s, e) => Execute(shell, dte), cmdId); menuItem.BeforeQueryStatus += (s, e) => OnBeforeQueryStatus(menuItem, dte); commandService.AddCommand(menuItem); }
/// <summary> /// Initializes a new instance of the <see cref="FindGroupByFunction"/> 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 FindGroupByFunction(Package package) { if (package == null) { throw new ArgumentNullException("package"); } this.package = package; 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); } DTE2 dte = ServiceProvider.GetService(typeof(EnvDTE.DTE)) as DTE2; FindEvents e = dte.Events.FindEvents; e.FindDone += Fe_FindDone; }
protected override void Initialize() { base.Initialize(); _dte = GetGlobalService(typeof(DTE)) as DTE; if (_dte == null) { return; } // Add our command handlers for menu (commands must exist in the .vsct file) OleMenuCommandService mcs = GetService(typeof(IMenuCommandService)) as OleMenuCommandService; if (mcs != null) { // Create the command for the menu item. CommandID sdkSearchCommandId = new CommandID(GuidList.GuidSdkSearchCmdSet, (int)PkgCmdIdList.CmdidCrmSdkSearch); OleMenuCommand sdkSearchMenuItem = new OleMenuCommand(SearchMenuItemCallback, sdkSearchCommandId); sdkSearchMenuItem.BeforeQueryStatus += SdkSearch_BeforeQueryStatus; sdkSearchMenuItem.Visible = false; mcs.AddCommand(sdkSearchMenuItem); } }
///////////////////////////////////////////////////////////////////////////// // Overriden Package Implementation #region Package Members /// <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() { Trace.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 commandId; OleMenuCommand menuItem; // Create the command for button Button1 commandId = new CommandID(GuidList.guidRubikToolsAddinCmdSet, (int)PkgCmdIDList.Button1); menuItem = new OleMenuCommand(Button1ExecuteHandler, Button1ChangeHandler, Button1QueryStatusHandler, commandId); mcs.AddCommand(menuItem); // Create the command for button Button3 commandId = new CommandID(GuidList.guidRubikToolsAddinCmdSet, (int)PkgCmdIDList.Button3); menuItem = new OleMenuCommand(Button3ExecuteHandler, Button3ChangeHandler, Button3QueryStatusHandler, commandId); mcs.AddCommand(menuItem); } }
///////////////////////////////////////////////////////////////////////////// // Overriden Package Implementation #region Package Members /// <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() { Trace.WriteLine(string.Format(CultureInfo.CurrentCulture, "Entering Initialize() of: {0}", this.ToString())); base.Initialize(); this._serviceProvider = this; _dte = this.GetService(typeof(DTE)) as DTE2; // 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 command for the menu item. CommandID menuCommandID = new CommandID(GuidList.guidTransformTemplatesToolCmdSet, (int)PkgCmdIDList.cmdidTransformProjectsTemplates); //MenuCommand menuItem = new MenuCommand(MenuItemCallback, menuCommandID ); //mcs.AddCommand( menuItem ); CommandID menuItemID = new CommandID(GuidList.guidTransformTemplatesToolCmdSet, (int)PkgCmdIDList.cmdidTransformProjectsTemplates); OleMenuCommand menuItem = new OleMenuCommand(this.OnTransformSelectedExec, menuItemID); menuItem.BeforeQueryStatus += new EventHandler(OnTransformSelectedStatus); mcs.AddCommand(menuItem); } }
///////////////////////////////////////////////////////////////////////////// // Overridden Package Implementation #region Package Members /// <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) { // Create the command for the menu item. CommandID menuCommandID = new CommandID(GuidList.guidminecraftpkgCmdSet, (int)PkgCmdIDList.cmdidProvisionMinecraftProject); OleMenuCommand menuItem = new OleMenuCommand(ProvisionMinecraftProject, menuCommandID); menuItem.ParametersDescription = "$"; mcs.AddCommand(menuItem); // Create the command for the menu item. CommandID menuCommandID2 = new CommandID(GuidList.guidminecraftpkgCmdSet, (int)PkgCmdIDList.cmdidBuildAndProvisionMinecraftProject); OleMenuCommand menuItem2 = new OleMenuCommand(BuildAndProvisionMinecraftProject, menuCommandID2); menuItem2.ParametersDescription = "$"; mcs.AddCommand(menuItem2); } }
///////////////////////////////////////////////////////////////////////////// // Overridden Package Implementation #region Package Members /// <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(); //Create Editor Factory. Note that the base Package class will call Dispose on it. base.RegisterEditorFactory(new EditorFactory(this)); // 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 command for the menu item. CommandID menuCommandID = new CommandID(GuidList.guidVSThrowawayPackageCmdSet, (int)PkgCmdIDList.startJamSession); MenuCommand menuItem = new MenuCommand(MenuItemCallback, menuCommandID); mcs.AddCommand(menuItem); // Create the command for the tool window CommandID toolwndCommandID = new CommandID(GuidList.guidVSThrowawayPackageCmdSet, (int)PkgCmdIDList.cmdidMyTool); MenuCommand menuToolWin = new MenuCommand(ShowToolWindow, toolwndCommandID); mcs.AddCommand(menuToolWin); } }
bool IsMenuCommandEnabled(CommandID commandID) { if (designSurface == null) { return(false); } IMenuCommandService menuCommandService = (IMenuCommandService)designSurface.GetService(typeof(IMenuCommandService)); if (menuCommandService == null) { return(false); } System.ComponentModel.Design.MenuCommand menuCommand = menuCommandService.FindCommand(commandID); if (menuCommand == null) { return(false); } //int status = menuCommand.OleStatus; return(menuCommand.Enabled); }
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 Initialize() { CommandID menuCommandID = new CommandID(GuidList.guidExtensionUpdaterCmdSet, (int)PkgCmdIDList.cmdEnableAutoUpdate); OleMenuCommand command = new OleMenuCommand(MasterSwitch, menuCommandID); command.BeforeQueryStatus += (s, e) => { SetVisibility(command); }; _mcs.AddCommand(command); CommandID checkAllCommandID = new CommandID(GuidList.guidExtensionUpdaterCmdSet, (int)PkgCmdIDList.cmdCheckAll); OleMenuCommand checkAll = new OleMenuCommand(CheckAll, checkAllCommandID); _mcs.AddCommand(checkAll); CommandID importCommandID = new CommandID(GuidList.guidImportExportCmdSet, (int)PkgCmdIDList.cmdImport); OleMenuCommand import = new OleMenuCommand(Import, importCommandID); _mcs.AddCommand(import); CommandID exportCommandID = new CommandID(GuidList.guidImportExportCmdSet, (int)PkgCmdIDList.cmdExport); OleMenuCommand export = new OleMenuCommand(Export, exportCommandID); _mcs.AddCommand(export); }
public void LaunchCommand() { UIThreadInvoker.Invoke((ThreadInvoker) delegate() { CommandID menuItemCmd = new CommandID(EgorBo.Xamaridea_VisualStudioPlugin.GuidList.guidXamaridea_VisualStudioPluginCmdSet, (int)EgorBo.Xamaridea_VisualStudioPlugin.PkgCmdIDList.cmdidOpenInIdeaCommand); // Create the DialogBoxListener Thread. string expectedDialogBoxText = string.Format(CultureInfo.CurrentCulture, "{0}\n\nInside {1}.MenuItemCallback()", "Xamaridea.VisualStudioPlugin", "EgorBo.Xamaridea_VisualStudioPlugin.Xamaridea_VisualStudioPluginPackage"); DialogBoxPurger purger = new DialogBoxPurger(NativeMethods.IDOK, expectedDialogBoxText); try { purger.Start(); TestUtils testUtils = new TestUtils(); testUtils.ExecuteCommand(menuItemCmd); } finally { Assert.IsTrue(purger.WaitForDialogThreadToTerminate(), "The dialog box has not shown"); } }); }
/// <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> void InitializePackage() { debuggerEvents = Utils.GetDTE().Events.DebuggerEvents; debuggerEvents.OnEnterBreakMode += DebuggerEvents_OnEnterBreakMode; Debug.WriteLine(string.Format(CultureInfo.CurrentCulture, "Entering Initialize() of: {0}", this.ToString())); // 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 command for the tool window CommandID toolwndCommandID = new CommandID(GuidList.guidCSScriptCmdSet, (int)PkgCmdIDList.cmdidMyTool); MenuCommand menuToolWin = new MenuCommand(ShowToolWindow, toolwndCommandID); mcs.AddCommand(menuToolWin); // Create the command for the menu item. CommandID menuCommandID = new CommandID(GuidList.guidCSScriptCmdSet, (int)PkgCmdIDList.cmdidMyCommand); MenuCommand menuItem = new MenuCommand(MenuItemCallback, menuCommandID); mcs.AddCommand(menuItem); } }
/// <include file='doc\OleMenuCommandService.uex' path='docs/doc[@for="OleMenuCommandService.GlobalInvoke"]/*' /> /// <devdoc> /// Invokes a command on the local form or in the global environment. /// The local form is first searched for the given command ID. If it is /// found, it is invoked. Otherwise the the command ID is passed to the /// global environment command handler, if one is available. /// </devdoc> public override bool GlobalInvoke(CommandID commandID) { // is it local? if (base.GlobalInvoke(commandID)) { return(true); } // pass it to the global handler IVsUIShell uiShellSvc = GetService(typeof(SVsUIShell)) as IVsUIShell; if (uiShellSvc != null) { Object dummy = null; Guid tmpGuid = commandID.Guid; if (NativeMethods.Failed(uiShellSvc.PostExecCommand(ref tmpGuid, (uint)commandID.ID, 0, ref dummy))) { return(false); } return(true); } return(false); }
private void OleMenuCommandBeforeQueryStatus(object sender, EventArgs e) { try { if (sender is OleMenuCommand oleMenuCommand) { CommandID commandId = oleMenuCommand.CommandID; if (commandId != null && mCommandsById.ContainsKey(commandId.ID)) { var bc = mCommandsById[commandId.ID]; oleMenuCommand.Supported = true; oleMenuCommand.Enabled = bc.IsEnabled(); oleMenuCommand.Visible = true; } } } catch (Exception ex) { System.Diagnostics.Debug.WriteLine(ex.ToString()); } }
public void LaunchCommand() { UIThreadInvoker.Invoke((ThreadInvoker) delegate() { CommandID menuItemCmd = new CommandID(Company.WomanOfParis.GuidList.guidWomanOfParisCmdSet, (int)Company.WomanOfParis.PkgCmdIDList.cmdidWomanOfParisCommand); // Create the DialogBoxListener Thread. string expectedDialogBoxText = string.Format(CultureInfo.CurrentCulture, "{0}\n\nInside {1}.MenuItemCallback()", "WomanOfParis", "Company.WomanOfParis.WomanOfParisPackage"); DialogBoxPurger purger = new DialogBoxPurger(NativeMethods.IDOK, expectedDialogBoxText); try { purger.Start(); TestUtils testUtils = new TestUtils(); testUtils.ExecuteCommand(menuItemCmd); } finally { Assert.IsTrue(purger.WaitForDialogThreadToTerminate(), "The dialog box has not shown"); } }); }
protected override void Initialize() { base.Initialize(); _logger = new Logger(); _dte = GetGlobalService(typeof(DTE)) as DTE; if (_dte == null) { return; } OleMenuCommandService mcs = GetService(typeof(IMenuCommandService)) as OleMenuCommandService; if (mcs != null) { CommandID publishCommandId = new CommandID(GuidList.GuidProjectMenuCommandsCmdSet, (int)PkgCmdIdList.CmdidPluginDeployerPublish); OleMenuCommand publishMenuItem = new OleMenuCommand(PublishItemCallback, publishCommandId); publishMenuItem.BeforeQueryStatus += PublishItem_BeforeQueryStatus; publishMenuItem.Visible = false; mcs.AddCommand(publishMenuItem); } }
/// <summary> /// Initializes a new instance of the <see cref="CapstoneDisassemblyCommand"/> 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="commandService">Command service to add command to, not null.</param> private CapstoneDisassemblyCommand(Package package, OleMenuCommandService commandService) { if (package == null) { throw new ArgumentNullException(nameof(package)); } if (commandService == null) { throw new ArgumentNullException(nameof(commandService)); } _package = package; CommandID menuCommandID = new CommandID(GuidList.guidCapstoneDisassemblyPackageCmdSet, (int)PkgCmdIDList.CapstoneDisassemblyCommandId); MenuCommand menuToolWin = new MenuCommand(Execute, menuCommandID); commandService.AddCommand(menuToolWin); var componentModel = package.GetService <SComponentModel, IComponentModel>(); var export = componentModel.DefaultExportProvider; _serviceProvider = export.GetExportedValue <SVsServiceProvider>(); }
private CommandDoxygenBrowsePage(Package package, App.CommandManager cmdManager, int commandId, bool useSourcebrowser, bool useLocal, string htmlDest) : base(package, cmdManager) { this.CommandId = commandId; this.UseSourcebrowser = useSourcebrowser; this.UseLocalDox = useLocal; this.htmlDest_ = htmlDest; if (package == null) { throw new ArgumentNullException("package"); } OleMenuCommandService commandService = this.ServiceProvider.GetService(typeof(IMenuCommandService)) as OleMenuCommandService; if (commandService != null) { var menuCommandID = new CommandID(CommandSet, CommandId); var menuItem = new OleMenuCommand(this.MenuItemCallback, menuCommandID); menuItem.BeforeQueryStatus += MenuItem_BeforeQueryStatus; commandService.AddCommand(menuItem); } }
///////////////////////////////////////////////////////////////////////////// // Overridden Package Implementation #region Package Members /// <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) { // Create the command for the menu item. CommandID menuCommandID = new CommandID(GuidList.guidVSpniff_VSPackageCmdSet, (int)PkgCmdIDList.cmdidFindMissingFiles); MenuCommand menuItem = new MenuCommand(FindForProjectCallback, menuCommandID); mcs.AddCommand(menuItem); menuCommandID = new CommandID(GuidList.guidVSpniff_VSPackageCmdSet, (int)PkgCmdIDList.cmdidFindMissingFilesAll); menuItem = new MenuCommand(FindAllCallback, menuCommandID); mcs.AddCommand(menuItem); } owp = null; dte = (DTE)GetService(typeof(DTE)); CreateVSpniffOutputPane(); }
/// <summary> /// Initializes a new instance of the <see cref="GoToDnSpy"/> 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 GoToDnSpy(Package package) { ThreadHelper.ThrowIfNotOnUIThread(); try { _package = package ?? throw new ArgumentNullException(nameof(package)); if (ServiceProvider.GetService(typeof(IMenuCommandService)) is OleMenuCommandService commandService) { // Add tools menu command var menuCommandId = new CommandID(PackageGuids.guidGoToDnSpyPackageCmdSetMenu, PackageIds.GoToDnSpyId); var menuItem = new MenuCommand(this.MenuItemCallback, menuCommandId); commandService.AddCommand(menuItem); // Add editor context menu command (right click) var ctxMenuCommand = new CommandID(PackageGuids.guidGoToDnSpyPackageCmdSetContextMenu, PackageIds.GoToDnSpyContextMenuId); var ctxMenuItem = new MenuCommand(this.MenuItemCallback, ctxMenuCommand); commandService.AddCommand(ctxMenuItem); } _statusBar = (IVsStatusbar)ServiceProvider.GetService(typeof(SVsStatusbar)); Assumes.Present(_statusBar); _componentModel = (IComponentModel)ServiceProvider.GetService(typeof(SComponentModel)); Assumes.Present(_componentModel); _editorAdaptersFactory = _componentModel.GetService <IVsEditorAdaptersFactoryService>(); Assumes.Present(_editorAdaptersFactory); _dte = (DTE)ServiceProvider.GetService(typeof(DTE)); Assumes.Present(_dte); } catch (Exception ex) { MessageBox.Show($"Some error in GoToDnSpy extensiton.\n Please take screenshot and create issue on github with this error\n{ex.ToString()}", "[GoToDnSpy] Error", MessageBoxButtons.OK, MessageBoxIcon.Error); throw; } }
// Constructors public MenuCommand(System.EventHandler handler, CommandID command) {}
public DesignerVerb(string text, System.EventHandler handler, CommandID startCommandID) {}
public void ShowContextMenu(CommandID menuID, int x, int y) { throw new NotImplementedException(); }
/// <summary> /// Send data to the comm device /// </summary> /// <param name="address">The address of the device eg. 000001</param> /// <param name="command">The command id of the message</param> /// <returns>The result of the transmission</returns> public override Boolean SendData(CommandID Command) { //Send blank array with defined command byte return SendData(Command, new byte[] { }); }
public virtual bool GlobalInvoke(CommandID commandId, object arg) {}
static StandardCommands() { // It seems that all static commands use this Guid values in MS impl Guid guidA = new Guid("5efc7975-14bc-11cf-9b2b-00aa00573819"); Guid guidB = new Guid("74d21313-2aee-11d1-8bfb-00a0c90f26f7"); // got command IDs by looking at StandardCommands.AlignBottom.ToString in MS impl AlignBottom = new CommandID (guidA, 1); AlignHorizontalCenters = new CommandID (guidA, 2); AlignLeft = new CommandID (guidA, 3); AlignRight = new CommandID (guidA, 4); AlignToGrid = new CommandID (guidA, 5); AlignTop = new CommandID (guidA, 6); AlignVerticalCenters = new CommandID (guidA, 7); ArrangeBottom = new CommandID (guidA, 8); ArrangeIcons = new CommandID (guidB, 12298); ArrangeRight = new CommandID (guidA, 9); BringForward = new CommandID (guidA, 10); BringToFront = new CommandID (guidA, 11); CenterHorizontally = new CommandID (guidA, 12); CenterVertically = new CommandID (guidA, 13); Copy = new CommandID (guidA, 15); Cut = new CommandID (guidA, 16); Delete = new CommandID (guidA, 17); F1Help = new CommandID (guidA, 377); Group = new CommandID (guidA, 20); HorizSpaceConcatenate = new CommandID (guidA, 21); HorizSpaceDecrease = new CommandID (guidA, 22); HorizSpaceIncrease = new CommandID (guidA, 23); HorizSpaceMakeEqual = new CommandID (guidA, 24); LineupIcons = new CommandID (guidB, 12299); LockControls = new CommandID (guidA, 369); MultiLevelRedo = new CommandID (guidA, 30); MultiLevelUndo = new CommandID (guidA, 44); Paste = new CommandID (guidA, 26); Properties = new CommandID (guidA, 28); PropertiesWindow = new CommandID (guidA, 235); Redo = new CommandID (guidA, 29); Replace = new CommandID (guidA, 230); SelectAll = new CommandID (guidA, 31); SendBackward = new CommandID (guidA, 32); SendToBack = new CommandID (guidA, 33); ShowGrid = new CommandID (guidA, 103); ShowLargeIcons = new CommandID (guidB, 12300); SizeToControl = new CommandID (guidA, 35); SizeToControlHeight = new CommandID (guidA, 36); SizeToControlWidth = new CommandID (guidA, 37); SizeToFit = new CommandID (guidA, 38); SizeToGrid = new CommandID (guidA, 39); SnapToGrid = new CommandID (guidA, 40); TabOrder = new CommandID (guidA, 41); Undo = new CommandID (guidA, 43); Ungroup = new CommandID (guidA, 45); VerbFirst = new CommandID (guidB, 8192); VerbLast = new CommandID (guidB, 8448); VertSpaceConcatenate = new CommandID (guidA, 46); VertSpaceDecrease = new CommandID (guidA, 47); VertSpaceIncrease = new CommandID (guidA, 48); VertSpaceMakeEqual = new CommandID (guidA, 49); ViewGrid = new CommandID (guidA, 125); #if NET_2_0 DocumentOutline = new CommandID (guidA, 239); ViewCode = new CommandID (guidA, 333); #endif }
public virtual MenuCommand FindCommand(CommandID commandID) {}
public abstract Boolean SendData(CommandID command, Array data);
public virtual bool GlobalInvoke(CommandID commandID) {}
public abstract Boolean SendData(CommandID Command);
public virtual void ShowContextMenu(CommandID menuID, int x, int y) {}
public MenuCommand FindCommand(CommandID commandID) { throw new NotImplementedException(); }
// Initialize the command identifiers. static StandardCommands() { Guid guid1; Guid guid2; guid1 = new Guid("{5efc7975-14bc-11cf-9b2b-00aa00573819}"); guid2 = new Guid("{74d21313-2aee-11d1-8bfb-00a0c90f26f7}"); AlignBottom = new CommandID(guid1, 1); AlignHorizontalCenters = new CommandID(guid1, 2); AlignLeft = new CommandID(guid1, 3); AlignRight = new CommandID(guid1, 4); AlignToGrid = new CommandID(guid1, 5); AlignTop = new CommandID(guid1, 6); AlignVerticalCenters = new CommandID(guid1, 7); ArrangeBottom = new CommandID(guid1, 8); ArrangeRight = new CommandID(guid1, 9); BringForward = new CommandID(guid1, 10); BringToFront = new CommandID(guid1, 11); CenterHorizontally = new CommandID(guid1, 12); CenterVertically = new CommandID(guid1, 13); Copy = new CommandID(guid1, 15); Cut = new CommandID(guid1, 16); Delete = new CommandID(guid1, 17); Group = new CommandID(guid1, 20); HorizSpaceConcatenate = new CommandID(guid1, 21); HorizSpaceDecrease = new CommandID(guid1, 22); HorizSpaceIncrease = new CommandID(guid1, 23); HorizSpaceMakeEqual = new CommandID(guid1, 24); Paste = new CommandID(guid1, 26); Properties = new CommandID(guid1, 28); Redo = new CommandID(guid1, 29); MultiLevelRedo = new CommandID(guid1, 30); SelectAll = new CommandID(guid1, 31); SendBackward = new CommandID(guid1, 32); SendToBack = new CommandID(guid1, 33); SizeToControl = new CommandID(guid1, 35); SizeToControlHeight = new CommandID(guid1, 36); SizeToControlWidth = new CommandID(guid1, 37); SizeToFit = new CommandID(guid1, 38); SizeToGrid = new CommandID(guid1, 39); SnapToGrid = new CommandID(guid1, 40); TabOrder = new CommandID(guid1, 41); Undo = new CommandID(guid1, 43); MultiLevelUndo = new CommandID(guid1, 44); Ungroup = new CommandID(guid1, 45); VertSpaceConcatenate = new CommandID(guid1, 46); VertSpaceDecrease = new CommandID(guid1, 47); VertSpaceIncrease = new CommandID(guid1, 48); VertSpaceMakeEqual = new CommandID(guid1, 49); ShowGrid = new CommandID(guid1, 103); ViewGrid = new CommandID(guid1, 125); Replace = new CommandID(guid1, 230); PropertiesWindow = new CommandID(guid1, 235); LockControls = new CommandID(guid1, 369); F1Help = new CommandID(guid1, 377); VerbFirst = new CommandID(guid2, 0x2000); VerbLast = new CommandID(guid2, 0x2100); ArrangeIcons = new CommandID(guid2, 0x300A); LineupIcons = new CommandID(guid2, 0x300B); ShowLargeIcons = new CommandID(guid2, 0x300C); }
public bool GlobalInvoke(CommandID commandID) { throw new NotImplementedException(); }
/// <summary> /// Send data to the comm device /// </summary> /// <param name="address">The address of the device eg. 000001</param> /// <param name="command">The command id of the message</param> /// <param name="data">The message payload</param> /// <returns>The result of the transmission</returns> public override Boolean SendData(CommandID command, Array data) { //Attempt to send data to the sepecified server try { //Create a new and local network stream for communication NetworkStream serverStream = theClient.GetStream(); //make a new array based on the amount of data to be sent + necessary command bytes byte[] message = new byte[data.Length + 3]; //Set value of necessary bytes //0xff packet header message.SetValue((byte)255, 0); //Number of remaining bytes in packet message.SetValue((byte)(data.Length + 1), 1); //command byte message.SetValue((byte)command, 2); //Copy all data into message array previously defined for (int idx = 0; idx < data.Length; idx++) { message.SetValue(data.GetValue(idx), idx + 3); } //Write array to server stream serverStream.Write(message, 0, message.Length); serverStream.Flush(); //return A-OK return true; } catch { //If there were any errors return false return false; } }
public MissionScriptNode(CommandID command, BinaryReader br) : this(command, br.ReadInt32()) { }