/// <summary>
/// Virtual method for processing the Delete menu status handler.
/// </summary>
/// <param name="command">Menu command called from the Visual Studio</param>
protected override void ProcessOnStatusDeleteCommand(MenuCommand command)
{
if (command != null)
{
command.Visible = command.Enabled = CanDelete();
}
}
/// <summary>
/// Initializes a new instance of the <see cref="PoorMansTSqlFormatterCommand"/> 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 PoorMansTSqlFormatterCommand(Package package)
{
if (package == null)
{
throw new ArgumentNullException("package");
}
this.package = package;
OleMenuCommandService commandService = this.ServiceProvider.GetService(typeof(IMenuCommandService)) as OleMenuCommandService;
if (commandService != null)
{
_applicationObject = Package.GetGlobalService(typeof(DTE)) as DTE;
_formattingManager = PoorMansTSqlFormatterPluginShared.Utils.GetFormattingManager(Properties.Settings.Default);
//Command cmd = _applicationObject.Commands.Item("Tools.FormatTSQLCode", -1);
//cmd.Bindings = "Text Editor::Ctrl+Shift+D";
var menuFormatCommandID = new CommandID(CommandSet, FormatCommandId);
var menuFormatItem = new MenuCommand(this.MenuFormatCallback, menuFormatCommandID);
commandService.AddCommand(menuFormatItem);
var menuOptionsCommandID = new CommandID(CommandSet, OptionsCommandId);
var menuOptionsItem = new MenuCommand(this.MenuOptionsCallback, menuOptionsCommandID);
commandService.AddCommand(menuOptionsItem);
_formatCommand = _applicationObject.Commands.Item("Tools.FormatTSQLCode", -1);
SetFormatHotkey();
}
}
/// <summary>
/// Initializes a new instance of the <see cref="BuildStartProject"/> 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 BuildStartProject(Package package)
{
if (package == null)
{
throw new ArgumentNullException("package");
}
this.package = package;
// Add a menu item.
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);
}
// Register as an advisory interface.
var solutionService = ServiceProvider.GetService(typeof(SVsSolution)) as IVsSolution;
if (solutionService != null)
{
solutionService.AdviseSolutionEvents(this, out m_EventSinkCookie);
}
}
private IntegrationTestServiceCommands(Package package)
{
if (package == null)
{
throw new ArgumentNullException(nameof(package));
}
_package = package;
var commandService = ServiceProvider.GetService(typeof(IMenuCommandService)) as OleMenuCommandService;
if (commandService != null)
{
var startServiceMenuCmdId = new CommandID(GrpIdIntegrationTestServiceCommands, CmdIdStartIntegrationTestService);
_startServiceMenuCmd = new MenuCommand(StartServiceCallback, startServiceMenuCmdId) {
Enabled = true,
Supported = true,
Visible = true
};
commandService.AddCommand(_startServiceMenuCmd);
var stopServiceMenuCmdId = new CommandID(GrpIdIntegrationTestServiceCommands, CmdIdStopIntegrationTestService);
_stopServiceMenuCmd = new MenuCommand(StopServiceCallback, stopServiceMenuCmdId) {
Enabled = false,
Supported = true,
Visible = false
};
commandService.AddCommand(_stopServiceMenuCmd);
}
}
protected override void Initialize()
{
base.Initialize();
control = new PendingChangesView(this);
// This is the user control hosted by the tool window; Note that, even if this class implements IDisposable,
// we are not calling Dispose on this object. This is because ToolWindowPane calls Dispose on
// the object returned by the Content property.
base.Content = control;
OleMenuCommandService mcs = GetService(typeof(IMenuCommandService)) as OleMenuCommandService;
var cmd = new CommandID(GuidList.guidSccProviderCmdSet, CommandId.icmdPendingChangesCommit);
var 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.icmdPendingChangesRefresh);
menu = new MenuCommand(new EventHandler(OnRefreshCommand), cmd);
mcs.AddCommand(menu);
sccProviderService = BasicSccProvider.GetServiceEx<SccProviderService>();
}
/// <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();
var core = Infrastructure.Core.Instance; // Init the core.
// 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.guidSuctionCmdSet, (int)PkgCmdIDList.cmdidSuctionSolution);
MenuCommand menuItem = new MenuCommand(MenuItemCallback_Solution, menuCommandID);
mcs.AddCommand(menuItem);
menuCommandID = new CommandID(GuidList.guidSuctionCmdProjectSet, (int)PkgCmdIDList.cmdidSuctionProject);
menuItem = new MenuCommand(MenuItemCallback_Project, menuCommandID);
mcs.AddCommand(menuItem);
menuCommandID = new CommandID(GuidList.guidSuctionCmdItemSet, (int)PkgCmdIDList.cmdidSuctionItem);
menuItem = new MenuCommand(MenuItemCallback_Item, menuCommandID);
mcs.AddCommand(menuItem);
}
}
protected override void ProcessOnStatusPasteCommand(System.ComponentModel.Design.MenuCommand cmd)
{
if (this.CurrentModelingDocView != null && this.CurrentDocData != null)
{
base.ProcessOnStatusPasteCommand(cmd);
}
}
/// <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);
}
/// <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();
Dte = Package.GetGlobalService(typeof(EnvDTE.DTE)) as DTE2;
// Add our command handlers for menu (commands must exist in the .vsct file)
_attachToIIS = new AttachToIIS(Dte);
OleMenuCommandService mcs = GetService(typeof(IMenuCommandService)) as OleMenuCommandService;
if ( null != mcs )
{
// Create the command for the menu item.
CommandID menuCommandID = new CommandID(GuidList.guidAlkampferVsix2010CmdSet, (int)PkgCmdIDList.cmdidAttachToIIS);
MenuCommand menuItem = new MenuCommand(_attachToIIS.MenuItemCallback, menuCommandID);
mcs.AddCommand( menuItem );
}
//Stop at first error command.
_stopBuildAtFirstErrorCommand = new StopBuildAtFirstError(Dte);
mcs = GetService(typeof(IMenuCommandService)) as OleMenuCommandService;
if (null != mcs)
{
// Create the command for the menu item.
CommandID menuCommandID = new CommandID(GuidList.guidAlkampferVsix2010CmdSet, (int)PkgCmdIDList.stopBuildAtFirstError);
MenuCommand menuItem = new MenuCommand(_stopBuildAtFirstErrorCommand.MenuItemCallback, menuCommandID);
_stopBuildAtFirstErrorCommand.ManageMenuItem(menuItem);
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()
{
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 menuCommandRunCoffeeScript = new CommandID(
GuidList.guidCoffeeScriptRunnerVSPackageCmdSet,
(int)PkgCmdIDList.cmdIdRunCoffeeScript
);
MenuCommand menuItem = new MenuCommand(
MenuItemCallback,
menuCommandRunCoffeeScript
);
mcs.AddCommand( menuItem );
CommandID menuCommandRunJavaScript = new CommandID(
GuidList.guidCoffeeScriptRunnerVSPackageCmdSet,
(int)PkgCmdIDList.cmdIdRunJavaScript
);
MenuCommand menuItem2 = new MenuCommand(
MenuItemCallback,
menuCommandRunJavaScript
);
mcs.AddCommand( menuItem2 );
}
base.dte = (EnvDTE80.DTE2)GetService(typeof(EnvDTE.DTE));
}
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.guidVSScriptsCmdSet, (int)PkgCmdIDList.cmdidConfigureScripts);
MenuCommand menuItem = new MenuCommand(HandleScriptsCmd, menuCommandID);
mcs.AddCommand(menuItem);
LoadScriptsList();
for (int i = 0; i < PkgCmdIDList.numScripts; ++i)
{
var cmdID = new CommandID(GuidList.guidVSScriptsCmdSet, PkgCmdIDList.cmdidScript0 + i);
var cmd = new OleMenuCommand(new EventHandler(HandleScriptMenuItem), cmdID);
cmd.BeforeQueryStatus += new EventHandler(HandleScriptBeforeQueryStatus);
cmd.Visible = true;
mcs.AddCommand(cmd);
}
}
}
/// <summary>
/// Initializes a new instance of the <see cref="AliaserCommand"/> 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 AliaserCommand(Package package)
{
if (package == null)
{
throw new ArgumentNullException("package");
}
this.package = package;
this.MainService = new AliaserService();
OleMenuCommandService commandService = this.ServiceProvider.GetService(typeof(IMenuCommandService)) as OleMenuCommandService;
if (commandService != null)
{
CommandID menuToAliasCommandID = new CommandID(MenuGroup, ALIASER_TO_ALIAS_COMMAND_ID);
CommandID menuToInstanceCommandID = new CommandID(MenuGroup, ALIASER_TO_INSTANCE_COMMAND_ID);
EventHandler transformAliasToInstace = this.TransformAliasToInstace;
EventHandler transformInstaceToAlias = this.TransformInstaceToAlias;
MenuCommand menuItemToInstace = new MenuCommand(transformAliasToInstace, menuToInstanceCommandID);
MenuCommand menuItemToAlias = new MenuCommand(transformInstaceToAlias, menuToAliasCommandID);
commandService.AddCommand(menuItemToInstace);
commandService.AddCommand(menuItemToAlias);
}
}
protected override void Initialize()
{
base.Initialize();
_dte = GetService(typeof(DTE)) as DTE2;
OleMenuCommandService mcs = GetService(typeof(IMenuCommandService)) as OleMenuCommandService;
CommandID cmdCustom = new CommandID(GuidList.guidOpenCommandLineCmdSet, (int)PkgCmdIDList.cmdidOpenCommandLine);
OleMenuCommand customItem = new OleMenuCommand(OpenCustom, cmdCustom);
customItem.BeforeQueryStatus += BeforeQueryStatus;
mcs.AddCommand(customItem);
CommandID cmdCmd = new CommandID(GuidList.guidOpenCommandLineCmdSet, (int)PkgCmdIDList.cmdidOpenCmd);
MenuCommand cmdItem = new MenuCommand(OpenCmd, cmdCmd);
mcs.AddCommand(cmdItem);
CommandID cmdPowershell = new CommandID(GuidList.guidOpenCommandLineCmdSet, (int)PkgCmdIDList.cmdidOpenPowershell);
MenuCommand powershellItem = new MenuCommand(OpenPowershell, cmdPowershell);
mcs.AddCommand(powershellItem);
CommandID cmdOptions = new CommandID(GuidList.guidOpenCommandLineCmdSet, (int)PkgCmdIDList.cmdidOpenOptions);
MenuCommand optionsItem = new MenuCommand((s, e) => { ShowOptionPage(typeof(Options)); }, cmdOptions);
mcs.AddCommand(optionsItem);
CommandID cmdExe = new CommandID(GuidList.guidOpenCommandLineCmdSet, (int)PkgCmdIDList.cmdExecuteCmd);
OleMenuCommand exeItem = new OleMenuCommand(ExecuteFile, cmdExe);
exeItem.BeforeQueryStatus += BeforeExeQuery;
mcs.AddCommand(exeItem);
}
/// <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()
{
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 tool window
CommandID toolwndCommandID = new CommandID(GuidList.guidDynamicStartItemExamplePackageCmdSet, PkgCmdIDList.cmdidShowDynamicItemCountEntryWindow);
MenuCommand menuToolWin = new MenuCommand(ShowToolWindow, toolwndCommandID);
mcs.AddCommand( menuToolWin );
//Add a 'dummy' entry for our menu, this entry has a null EventHandler as it will never be 'executed'
//(you can't 'execute' a menu), and it doesn't set any properties as the default value of Visible is
//true and we only want this handler in place so that the command system will find it once our package
//is loaded and thus cause our main menu item to become visible.
CommandID menuID = new CommandID(GuidList.guidDynamicStartItemExamplePackageCmdSet, PkgCmdIDList.mnuidMyMenu);
MenuCommand menu = new MenuCommand(null, menuID);
mcs.AddCommand(menu);
//Add the DynamicItemMenuCommand that will be responsible for the expansion of our root item into N items
//at runtime. Where N is the value the user has entered into our tool window.
CommandID dynamicItemRootId = new CommandID(GuidList.guidDynamicStartItemExamplePackageCmdSet, PkgCmdIDList.cmdidMyDynamicStartItem);
DynamicItemMenuCommand dynamicMenuCommand = new DynamicItemMenuCommand(dynamicItemRootId,
IsValidDynamicItem,
OnInvokedDynamicItem,
OnBeforeQueryStatusDynamicItem);
mcs.AddCommand(dynamicMenuCommand);
}
}
/// <summary>
/// Initializes a new instance of the <see cref="LocatorWindowCommand"/> class.
/// Adds our command handlers for menu (commands must exist in the command table file)
/// </summary>
/// <param name="package">Owner package, not null.</param>
private LocatorWindowCommand(Package package)
{
if (package == null)
{
throw new ArgumentNullException("package");
}
this.package = package;
OleMenuCommandService commandService = ServiceProvider.GetService(typeof(IMenuCommandService)) as OleMenuCommandService;
if (commandService != null)
{
var menuCommandID = new CommandID(CommandSet, CommandId);
var menuItem = new MenuCommand(this.ShowToolWindow, menuCommandID);
commandService.AddCommand(menuItem);
}
// Get the instance number 0 of this tool window. This window is single instance so this instance
// is actually the only one.
// The last flag is set to true so that if the tool window does not exists it will be created.
_locatorWindow = package.FindToolWindow(typeof(LocatorWindow), 0, true) as LocatorWindow;
if ((null == _locatorWindow) || (null == _locatorWindow.Frame))
{
throw new NotSupportedException("Cannot create tool window");
}
_locator = new Locator();
_solution = ServiceProvider.GetService(typeof(SVsSolution)) as IVsSolution;
_solution.AdviseSolutionEvents(_locator, out _cookie);
_locatorWindow.SetLocator(_locator);
_locator.StartWorkerThread();
}
/// <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 References context menu.
CommandID menuCommandID = new CommandID(GuidList.guidILSpyAddInCmdSet, (int)PkgCmdIDList.cmdidOpenReferenceInILSpy);
MenuCommand menuItem = new MenuCommand(OpenReferenceInILSpyCallback, menuCommandID);
mcs.AddCommand(menuItem);
// Create the command for the Project context menu, to open the output assembly.
CommandID menuCommandID2 = new CommandID(GuidList.guidILSpyAddInCmdSet, (int)PkgCmdIDList.cmdidOpenProjectOutputInILSpy);
MenuCommand menuItem2 = new MenuCommand(OpenProjectOutputInILSpyCallback, menuCommandID2);
mcs.AddCommand(menuItem2);
// Create the command for the code window context menu.
CommandID menuCommandID3 = new CommandID(GuidList.guidILSpyAddInCmdSet, (int)PkgCmdIDList.cmdidOpenCodeItemInILSpy);
OleMenuCommand menuItem3 = new OleMenuCommand(OpenCodeItemInILSpyCallback, menuCommandID3);
menuItem3.BeforeQueryStatus += OpenCodeItemInILSpyCallback_BeforeQueryStatus;
mcs.AddCommand(menuItem3);
// Create the command for the Tools menu item.
CommandID menuCommandID4 = new CommandID(GuidList.guidILSpyAddInCmdSet, (int)PkgCmdIDList.cmdidOpenILSpy);
MenuCommand menuItem4 = new MenuCommand(OpenILSpyCallback, menuCommandID4);
mcs.AddCommand(menuItem4);
}
}
/// <summary>
/// This method is called by the base class during SetSite. At this point the service provider
/// for the package is set and all the services are available.
/// </summary>
protected override void Initialize()
{
// Call the base implementation to finish the initialization of the package.
base.Initialize();
// Get the OleMenuCommandService object to add the MenuCommand that will handle the command
// defined by this package.
OleMenuCommandService mcs = GetService(typeof(IMenuCommandService)) as OleMenuCommandService;
if (null == mcs)
{
// If for some reason we can not get the OleMenuCommandService, then we can not add the handler
// for the command, so we can exit now.
Debug.WriteLine("Can not get the OleMenuCommandService from the base class.");
return;
}
// Define the command and add it to the command service.
CommandID id = new CommandID(GuidsList.guidClientCmdSet, ClientPkgCmdIDList.cmdidClientGetGlobalService);
MenuCommand command = new MenuCommand(new EventHandler(GetGlobalServiceCallback), id);
mcs.AddCommand(command);
// Add the command that will try to get the local server and that is expected to fail.
id = new CommandID(GuidsList.guidClientCmdSet, ClientPkgCmdIDList.cmdidClientGetLocalService);
command = new MenuCommand(new EventHandler(GetLocalServiceCallback), id);
mcs.AddCommand(command);
// Add the command that will call the local service using the global one.
id = new CommandID(GuidsList.guidClientCmdSet, ClientPkgCmdIDList.cmdidClientGetLocalUsingGlobal);
command = new MenuCommand(new EventHandler(GetLocalUsingGlobalCallback), id);
mcs.AddCommand(command);
}
/// <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.guidZipNShareCmdSet, (int)PkgCmdIDList.cmdidZipNShareOptions);
MenuCommand menuItem = new MenuCommand(OptionsMenuItemCallback, menuCommandID);
CommandID menuCommandRunID = new CommandID(menuItem.CommandID.Guid, (int)PkgCmdIDList.cmdidZipNShareRun);
MenuCommand menuItemRun = new MenuCommand(RunMenuItemCallback, menuCommandRunID);
mcs.AddCommand(menuItemRun);
mcs.AddCommand(menuItem);
// Create the command for the tool window
CommandID toolwndCommandID = new CommandID(GuidList.guidZipNShareCmdSet, (int)PkgCmdIDList.cmdidZipAndShareToolWindow);
MenuCommand menuToolWin = new MenuCommand(ShowToolWindow, toolwndCommandID);
mcs.AddCommand(menuToolWin);
}
}
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 );
}
/// <summary>
/// Initialization of the package; this method is called right after the package is sited, so this is the place
/// where you can put all the initialization code that rely on services provided by VisualStudio.
/// </summary>
protected override void Initialize()
{
Debug.WriteLine(string.Format(CultureInfo.CurrentCulture, "Entering Initialize() of: {0}", this.ToString()));
base.Initialize();
// Add our command handlers for menu (commands must exist in the .vsct file)
OleMenuCommandService mcs = GetService(typeof(IMenuCommandService)) as OleMenuCommandService;
if (null != mcs)
{
CommandID waqsServerCommandID = new CommandID(GuidList.guidWAQSProjectCmdSet, (int)PkgCmdIDList.WAQSServerId);
MenuCommand waqsServerItem = new MenuCommand(WAQSServerCallback, waqsServerCommandID);
mcs.AddCommand(waqsServerItem);
CommandID waqsServerMockCommandID = new CommandID(GuidList.guidWAQSProjectCmdSet, (int)PkgCmdIDList.WAQSServerMockId);
MenuCommand waqsServerMockItem = new MenuCommand(WAQSServerMockCallback, waqsServerMockCommandID);
mcs.AddCommand(waqsServerMockItem);
CommandID waqsClientWPFCommandID = new CommandID(GuidList.guidWAQSProjectCmdSet, (int)PkgCmdIDList.WAQSClientWPFId);
MenuCommand waqsClientWPFItem = new MenuCommand(WAQSClientWPFCallback, waqsClientWPFCommandID);
mcs.AddCommand(waqsClientWPFItem);
CommandID waqsClientPCLCommandID = new CommandID(GuidList.guidWAQSProjectCmdSet, (int)PkgCmdIDList.WAQSClientPCLId);
MenuCommand waqsClientPCLItem = new MenuCommand(WAQSClientPCLCallback, waqsClientPCLCommandID);
mcs.AddCommand(waqsClientPCLItem);
CommandID waqsUpdateGeneratedCodeCommandID = new CommandID(GuidList.guidWAQSProjectCmdSet, (int)PkgCmdIDList.WAQSUpdateGeneratedCodeId);
MenuCommand waqsUpdateGeneratedCodeItem = new MenuCommand(WAQSUpdateGeneratedCodeCallback, waqsUpdateGeneratedCodeCommandID);
mcs.AddCommand(waqsUpdateGeneratedCodeItem);
CommandID waqsInitVMCommandID = new CommandID(GuidList.guidWAQSFileCmdSet, (int)PkgCmdIDList.WAQSInitVMId);
MenuCommand waqsInitVMItem = new MenuCommand(WAQSInitVMCallback, waqsInitVMCommandID);
mcs.AddCommand(waqsInitVMItem);
}
}
/// <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.guidDuplicateFileCmdSet, (int)PkgCmdIDList.cmdidDuplicateCmd);
MenuCommand menuItem = new MenuCommand(MenuItemCallbackDuplicate, menuCommandID);
mcs.AddCommand(menuItem);
}
// Add our command handlers for menu (commands must exist in the .vsct file)
if (null != mcs)
{
// Create the command for the menu item.
CommandID menuCommandID = new CommandID(GuidList.guidRefreshCmdSet, (int)PkgCmdIDList.cmdidRefreshCmd);
MenuCommand menuItem = new MenuCommand(MenuItemCallbackRefresh, menuCommandID);
mcs.AddCommand(menuItem);
}
// Override Edit.Delete command
_applicationObject = (DTE)GetService(typeof(DTE));
var command = _applicationObject.Commands.Item("Edit.Delete");
_removeEvent = _applicationObject.Events.CommandEvents[command.Guid, command.ID];
_removeEvent.BeforeExecute += OnBeforeDeleteCommand;
}
protected override void ProcessOnStatusDeleteAllCommand(System.ComponentModel.Design.MenuCommand cmd)
{
bool bAllowDeletion = true;
if (this.SelectedElement == null && this.SelectedRole != null)
{
if (this.SelectedRole.Id == LibraryModelContextHasClasses.DomainClassDomainRoleId)
{
bAllowDeletion = false;
}
else if (this.SelectedRole.Id == LibraryModelContextHasDiagramClasses.DiagramClassDomainRoleId)
{
bAllowDeletion = false;
}
}
if (bAllowDeletion)
{
base.ProcessOnStatusDeleteAllCommand(cmd);
}
else
{
// disable the menu command
cmd.Enabled = false;
}
}
/// <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}", 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 xBuildMenuCommandID = new CommandID(GuidList.GuidMonoHelperCmdSet, (int)PkgCmdIDList.XBuildCommandID);
MenuCommand xBuildMenuItem = new MenuCommand(XBuildMenuItemCallback, xBuildMenuCommandID);
mcs.AddCommand(xBuildMenuItem);
CommandID xRebuildMenuCommandID = new CommandID(GuidList.GuidMonoHelperCmdSet, (int)PkgCmdIDList.XRebuildCommandID);
MenuCommand xRebuildMenuItem = new MenuCommand(XRebuildMenuItemCallback, xRebuildMenuCommandID);
mcs.AddCommand(xRebuildMenuItem);
CommandID startNetMenuCommandID = new CommandID(GuidList.GuidMonoHelperCmdSet, (int)PkgCmdIDList.StartNetCommandID);
MenuCommand startNetMenuItem = new MenuCommand(StartNetMenuItemCallback, startNetMenuCommandID);
mcs.AddCommand(startNetMenuItem);
CommandID startMonoMenuCommandID = new CommandID(GuidList.GuidMonoHelperCmdSet, (int)PkgCmdIDList.StartMonoCommandID);
MenuCommand startMonoMenuItem = new MenuCommand(StartMonoMenuItemCallback, startMonoMenuCommandID);
mcs.AddCommand(startMonoMenuItem);
CommandID debugNetMenuCommandID = new CommandID(GuidList.GuidMonoHelperCmdSet, (int)PkgCmdIDList.DebugNetCommandID);
MenuCommand debugMenuNetItem = new MenuCommand(DebugNetMenuItemCallback, debugNetMenuCommandID);
mcs.AddCommand(debugMenuNetItem);
}
}
public PendingChangesToolWindow()
: base(null)
{
// set the window title
this.Caption = Resources.ResourceManager.GetString("PendingChangesToolWindowCaption");
//// set the CommandID for the window ToolBar
this.ToolBar = new CommandID(GuidList.guidSccProviderCmdSet, CommandId.imnuPendingChangesToolWindowToolbarMenu);
// set the icon for the frame
this.BitmapResourceID = CommandId.ibmpToolWindowsImages; // bitmap strip resource ID
this.BitmapIndex = CommandId.iconSccProviderToolWindow; // index in the bitmap strip
control = new PendingChangesView();
// This is the user control hosted by the tool window; Note that, even if this class implements IDisposable,
// we are not calling Dispose on this object. This is because ToolWindowPane calls Dispose on
// the object returned by the Content property.
base.Content = control;
OleMenuCommandService mcs = GetService(typeof(IMenuCommandService)) as OleMenuCommandService;
var cmd = new CommandID(GuidList.guidSccProviderCmdSet, CommandId.icmdPendingChangesCommit);
var 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);
}
/// <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();
OleMenuCommandService mcs = GetService(typeof(IMenuCommandService)) as OleMenuCommandService;
if ( null != mcs )
{
// Create the command for the menu item.
CommandID menuCommandID = new CommandID(GuidList.guidChoreoCmdSet, (int)PkgCmdIDList.cmdidMyCommand);
MenuCommand menuItem = new MenuCommand(MenuItemCallback, menuCommandID );
mcs.AddCommand( menuItem );
//// Create the command for the tool window
//CommandID toolwndCommandID = new CommandID(GuidList.guidChoreoCmdSet, (int)PkgCmdIDList.cmdidMyTool);
//MenuCommand menuToolWin = new MenuCommand(ShowToolWindow, toolwndCommandID);
//mcs.AddCommand( menuToolWin );
}
MacroManager.Initialize(this);
MacroManager.LoadMacros();
var registerPriorityCommandTarget = (IVsRegisterPriorityCommandTarget) GetService(typeof(SVsRegisterPriorityCommandTarget));
uint pdwCookie;
ErrorHandler.ThrowOnFailure(registerPriorityCommandTarget.RegisterPriorityCommandTarget(0, new MacroCommandTarget(), out pdwCookie));
}
/////////////////////////////////////////////////////////////////////////////
// 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() {
((IServiceContainer)this).AddService(typeof(NpgsqlProviderObjectFactory), new NpgsqlProviderObjectFactory(), true);
base.Initialize();
// Add our command handlers for menu (commands must exist in the .vsct file)
OleMenuCommandService mcs = GetService(typeof(IMenuCommandService)) as OleMenuCommandService;
if (null != mcs) {
// Create the command for the menu item.
{
CommandID menuCommandID = new CommandID(GuidList.guidNpgsqlDdexProviderCmdSetToolsMenu, (int)PkgCmdIDList.cmdidSetupNpgsql);
MenuCommand menuItem = new MenuCommand(MenuItemSetupNpgsqlDdexProvider, menuCommandID);
mcs.AddCommand(menuItem);
}
{
CommandID menuCommandID = new CommandID(GuidList.guidNpgsqlDdexProviderCmdSetToolsMenu, (int)PkgCmdIDList.cmdidUninstNpgsql);
MenuCommand menuItem = new MenuCommand(MenuItemUninstNpgsqlDdexProvider, menuCommandID);
mcs.AddCommand(menuItem);
}
{
CommandID menuCommandID = new CommandID(GuidList.guidNpgsqlDdexProviderCmdSetProjMenu, (int)PkgCmdIDList.cmdidCheckNpgsql);
MenuCommand menuItem = new MenuCommand(MenuItemCheckNpgsqlDdexProvider, menuCommandID);
mcs.AddCommand(menuItem);
}
}
AppDomain.CurrentDomain.AssemblyResolve += CurrentDomain_AssemblyResolve;
}
/// <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 )
{
// Create the command for the menu item.
CommandID menuCommandID = new CommandID(GuidList.guidReviewPal2010CmdSet, (int)PkgCmdIDList.cmdidReviewPal);
MenuCommand menuItem = new MenuCommand(MenuItemCallback, menuCommandID );
mcs.AddCommand( menuItem );
// Create the command for the tool window
CommandID toolwndCommandID = new CommandID(GuidList.guidReviewPal2010CmdSet, (int)PkgCmdIDList.cmdidReviewWindow);
MenuCommand menuToolWin = new MenuCommand(ShowToolWindow, toolwndCommandID);
mcs.AddCommand( menuToolWin );
}
VSIDEHelper.VisualStudioInstance = Package.GetGlobalService(typeof(DTE)) as DTE2;
solutionEvents = VSIDEHelper.VisualStudioInstance.Events.SolutionEvents;
solutionEvents.Opened += new _dispSolutionEvents_OpenedEventHandler(SolutionEvents_Opened);
solutionEvents.BeforeClosing += new _dispSolutionEvents_BeforeClosingEventHandler(solutionEvents_BeforeClosing);
ToolWindowPane window = this.FindToolWindow(typeof(ReviewToolWindow), 0, true);
reviewWindow = (ReviewWindow)((ReviewToolWindow)window).Content;
//initialize the Utility class
Utils.Initialize();
}
/// <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();
//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.guidVSPackage2CmdSet, (int)PkgCmdIDList.cmdidMyCommand);
MenuCommand menuItem = new MenuCommand(MenuItemCallback, menuCommandID );
mcs.AddCommand( menuItem );
// Create project command
CommandID projectMenuCmd = new CommandID(GuidList.guidVSPackage2CmdSet, (int)PkgCmdIDList.cmdidMyProjectCommand);
MenuCommand menuProjCmd = new MenuCommand(MenuItemCallback, projectMenuCmd);
mcs.AddCommand(menuProjCmd);
// Create the command for the tool window
CommandID toolwndCommandID = new CommandID(GuidList.guidVSPackage2CmdSet, (int)PkgCmdIDList.cmdidMyTool);
MenuCommand menuToolWin = new MenuCommand(ShowToolWindow, toolwndCommandID);
mcs.AddCommand( menuToolWin );
}
}
protected override void Initialize()
{
base.Initialize();
_dte = GetGlobalService(typeof(DTE)) as DTE;
if (_dte == null)
return;
OleMenuCommandService mcs = GetService(typeof(IMenuCommandService)) as OleMenuCommandService;
if (mcs == null)
return;
//Solution Node
CommandID solutionMenuCommandId = new CommandID(GuidList.GuidVsPtcCmdSet, (int)PkgCmdIdList.CmdidMyCommandSolution);
MenuCommand solutionmMenuItem = new MenuCommand(SolutionMenuCallback, solutionMenuCommandId);
mcs.AddCommand(solutionmMenuItem);
//Project Node
CommandID projectMenuCommandId = new CommandID(GuidList.GuidVsPtcCmdSet, (int)PkgCmdIdList.CmdidMyCommandProject);
MenuCommand projectmMenuItem = new MenuCommand(ProjectMenuCallback, projectMenuCommandId);
mcs.AddCommand(projectmMenuItem);
//Project Item Node - File
CommandID itemFileMenuCommandId = new CommandID(GuidList.GuidVsPtcCmdSet, (int)PkgCmdIdList.CmdidMyCommandItemFile);
MenuCommand itemFileMenuItem = new MenuCommand(ItemFileMenuCallback, itemFileMenuCommandId);
mcs.AddCommand(itemFileMenuItem);
//Project Item Node - Folder
CommandID itemFolderMenuCommandId = new CommandID(GuidList.GuidVsPtcCmdSet, (int)PkgCmdIdList.CmdidMyCommandItemFolder);
MenuCommand itemFolderMenuItem = new MenuCommand(ItemFolderMenuCallback, itemFolderMenuCommandId);
mcs.AddCommand(itemFolderMenuItem);
}
protected override void Initialize()
{
base.Initialize();
var mcs = GetService(typeof (IMenuCommandService)) as OleMenuCommandService;
if (null != mcs)
{
var menuCommandID = new CommandID(GuidList.guidSSDTDevPack_VSPackageCmdSet,
(int) PkgCmdIDList.SSDTDevPackQuickDeploy);
var menuItem = new MenuCommand(MenuItemCallback, menuCommandID);
mcs.AddCommand(menuItem);
var toolwndCommandID = new CommandID(GuidList.guidSSDTDevPack_VSPackageCmdSet,
(int) PkgCmdIDList.SSDTDevPackMergeUi);
var menuToolWin = new MenuCommand(ShowMergeToolWindow, toolwndCommandID);
mcs.AddCommand(menuToolWin);
menuCommandID = new CommandID(GuidList.guidSSDTDevPack_VSPackageCmdSet,
(int) PkgCmdIDList.SSDTDevPackNameConstraints);
menuItem = new MenuCommand(NameConstraintsCalled, menuCommandID);
mcs.AddCommand(menuItem);
}
}
/// <summary>
/// Hook up the context menu handlers.
/// </summary>
public void Initialize(IMenuCommandService menuCommandService)
{
if (menuCommandService != null)
{
_addMenuItem = AddCommandHandler(menuCommandService, ID.RoslynCommands.AddAnalyzer, AddAnalyzerHandler);
_projectAddMenuItem = AddCommandHandler(menuCommandService, ID.RoslynCommands.ProjectAddAnalyzer, AddAnalyzerHandler);
_projectContextAddMenuItem = AddCommandHandler(menuCommandService, ID.RoslynCommands.ProjectContextAddAnalyzer, AddAnalyzerHandler);
_referencesContextAddMenuItem = AddCommandHandler(menuCommandService, ID.RoslynCommands.ReferencesContextAddAnalyzer, AddAnalyzerHandler);
_removeMenuItem = AddCommandHandler(menuCommandService, ID.RoslynCommands.RemoveAnalyzer, RemoveAnalyzerHandler);
_openRuleSetMenuItem = AddCommandHandler(menuCommandService, ID.RoslynCommands.OpenRuleSet, OpenRuleSetHandler);
_setSeverityErrorMenuItem = AddCommandHandler(menuCommandService, ID.RoslynCommands.SetSeverityError, SetSeverityHandler);
_setSeverityWarningMenuItem = AddCommandHandler(menuCommandService, ID.RoslynCommands.SetSeverityWarning, SetSeverityHandler);
_setSeverityInfoMenuItem = AddCommandHandler(menuCommandService, ID.RoslynCommands.SetSeverityInfo, SetSeverityHandler);
_setSeverityHiddenMenuItem = AddCommandHandler(menuCommandService, ID.RoslynCommands.SetSeverityHidden, SetSeverityHandler);
_setSeverityNoneMenuItem = AddCommandHandler(menuCommandService, ID.RoslynCommands.SetSeverityNone, SetSeverityHandler);
UpdateMenuItemVisibility();
UpdateMenuItemsChecked();
if (_tracker != null)
{
_tracker.SelectedHierarchyChanged += SelectedHierarchyChangedHandler;
_tracker.SelectedDiagnosticItemsChanged += SelectedDiagnosticItemsChangedHandler;
_tracker.SelectedItemIdChanged += SelectedItemIdChangedHandler;
}
var buildManager = (IVsSolutionBuildManager)_serviceProvider.GetService(typeof(SVsSolutionBuildManager));
uint cookie;
buildManager.AdviseUpdateSolutionEvents(this, out cookie);
}
}
/** methods */
public BatchBuilder()
{
// Create the command for the tool window
var ToolWindowCommandId = new CommandID(GuidList.UnrealVSCmdSet, BatchBuilderToolWindowId);
var ToolWindowMenuCommand = new MenuCommand(ShowToolWindow, ToolWindowCommandId);
UnrealVSPackage.Instance.MenuCommandService.AddCommand(ToolWindowMenuCommand);
}
/// If a command is no longer viable for a designer, it is removed.
public override void RemoveCommand(System.ComponentModel.Design.MenuCommand command)
{
if (commands != null)
{
// Hashtable already has nothing happen if the command isn't there.
commands.Remove(command.CommandID);
}
}
/// called to remove a MenuCommand
public void RemoveCommand(System.ComponentModel.Design.MenuCommand command)
{
if (command == null)
{
throw new ArgumentException("command");
}
commands.Remove(command.CommandID);
}
// Gestion des selections du contexteMenu
private void OnMenuClicked(object sender, EventArgs e)
{
VelerSoftware.Design.Toolkit.KryptonContextMenuItem menuItem = sender as VelerSoftware.Design.Toolkit.KryptonContextMenuItem;
if (menuItem != null && menuItem.Tag is System.ComponentModel.Design.MenuCommand)
{
System.ComponentModel.Design.MenuCommand command = menuItem.Tag as System.ComponentModel.Design.MenuCommand;
command.Invoke();
}
}
private void OnMenuClicked(object sender, EventArgs args)
{
ToolStripMenuItem item = sender as ToolStripMenuItem;
if (item != null)
{
MenuCommand cmd = item.Tag as MenuCommand;
cmd.Invoke();
}
}
// Ajout de command satndard au service
public override void AddCommand(System.ComponentModel.Design.MenuCommand command)
{
try
{
menuCommandService.AddCommand(command);
}
catch
{
}
}
// Gestion des selections du contexteMenu
private void OnMenuClicked(object sender, EventArgs e)
{
ToolStripDropDownButton menuItem = sender as ToolStripDropDownButton;
if (menuItem != null && menuItem.Tag is System.ComponentModel.Design.MenuCommand)
{
System.ComponentModel.Design.MenuCommand command = menuItem.Tag as System.ComponentModel.Design.MenuCommand;
command.Invoke();
}
}
//roman//
#region Implementation of IMenuCommandService
/// called to add a MenuCommand
public void AddCommand(System.ComponentModel.Design.MenuCommand command)
{
if (command == null)
{
throw new ArgumentException("command");
}
// don't add commands twice
if (FindCommand(command.CommandID) == null)
{
commands.Add(command.CommandID, command);
}
}
/// If a designer supports a MenuCommand, it will add it here.
public override void AddCommand(System.ComponentModel.Design.MenuCommand command)
{
if (commands == null)
{
commands = new Hashtable();
}
// Only add a command if we haven't already.
if (FindCommand(command.CommandID) == null)
{
commands.Add(command.CommandID, command);
}
}
private ToolStripMenuItem[] GetSelectionMenuItems()
{
List <ToolStripMenuItem> menuItems = new List <ToolStripMenuItem>();
ISelectionService selectionService = GetService(typeof(ISelectionService)) as ISelectionService;
if (selectionService != null)
{
ICollection selectedComps = selectionService.GetSelectedComponents();
Dictionary <CommandID, string> selectionCommands = new Dictionary <CommandID, string>();
selectionCommands.Add(StandardCommands.Cut, "Cut");
selectionCommands.Add(StandardCommands.Copy, "Copy");
selectionCommands.Add(StandardCommands.Paste, "Paste");
selectionCommands.Add(StandardCommands.Delete, "Delete");
selectionCommands.Add(StandardCommands.Undo, "Undo");
selectionCommands.Add(StandardCommands.Redo, "Redo");
foreach (CommandID id in selectionCommands.Keys)
{
MenuCommand command = FindCommand(id);
if (command != null)
{
ToolStripMenuItem menuItem = new ToolStripMenuItem(selectionCommands[id], null, new EventHandler(OnMenuClicked));
menuItem.Tag = command;
menuItems.Add(menuItem);
}
}
if (selectedComps != null && selectedComps.Count == 1)
{
object[] comps = new object[selectedComps.Count];
selectedComps.CopyTo(comps, 0);
if (comps[0].GetType() == typeof(TabControl))
{
foreach (DesignerVerb verb in Verbs)
{
if (verb != null)
{
ToolStripMenuItem menuItem = new ToolStripMenuItem(verb.Text, null, new EventHandler(OnMenuClicked));
menuItem.Tag = verb;
menuItems.Add(menuItem);
}
}
}
}
}
return(menuItems.ToArray());
}
/// If a designer supports a MenuCommand, it will add it here.
public void AddCommand(System.ComponentModel.Design.MenuCommand command)
{
if (commands == null)
{
commands = new Hashtable();
defaultCommands = new DefaultMenuCommands(host as IServiceProvider);
defaultCommands.AddTo(this);
}
// Only add a command if we haven't already.
if (FindCommand(command.CommandID) == null)
{
commands.Add(command.CommandID, command);
}
}
/// <summary>
/// Override to stop the "Delete" command appearing for certain elements.
/// </summary>
protected override void ProcessOnStatusDeleteCommand(System.ComponentModel.Design.MenuCommand command)
{
bool bAllowDeletion = true;
if (this.SelectedElement is DomainClass)
{
if ((this.SelectedElement as DomainClass).IsDomainModel)
{
bAllowDeletion = false;
}
}
if (this.SelectedElement is Validation)
{
bAllowDeletion = false;
}
if (this.SelectedElement is DiagramClass)
{
bAllowDeletion = false;
}
if (this.SelectedElement is View || this.SelectedElement is ModelTree)
{
bAllowDeletion = false;
}
if (this.SelectedElement is MetaModelLibrary)
{
command.Enabled = true;
command.Visible = true;
//findDependencies.Enabled = true;
//findDependencies.Visible = true;
return;
}
if (bAllowDeletion)
{
base.ProcessOnStatusDeleteCommand(command);
}
else
{
// disable the menu command
command.Enabled = false;
}
}
private bool IsMenuCommandEnabled(CommandID commandID)
{
if (this.designSurface == null)
{
return false;
}
IMenuCommandService service = (IMenuCommandService) this.designSurface.GetService(typeof(IMenuCommandService));
if (service == null)
{
return false;
}
System.ComponentModel.Design.MenuCommand command = service.FindCommand(commandID);
if (command == null)
{
return false;
}
return command.Enabled;
}
/// <summary>
/// Initializes a new instance of the <see cref="MenuCommand"/> 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 MenuCommand(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 System.ComponentModel.Design.MenuCommand(this.MenuItemCallback, menuCommandID);
commandService.AddCommand(menuItem);
}
}
/// <summary>
/// 判断一个命令标识符是否可用
/// </summary>
/// <param name="commandID"></param>
/// <returns></returns>
public bool IsMenuCommandEnabled(CommandID commandID)
{
if (_designSurface == null)
{
return(false);
}
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 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);
}
return(menuCommand.Enabled);
}
private void OnStatusPaste(object sender, System.EventArgs e)
{
System.ComponentModel.Design.MenuCommand menuCommand = (System.ComponentModel.Design.MenuCommand)sender;
if (this.SelectedElement == null && this.SelectedRole == null)
{
menuCommand.Enabled = false;
return;
}
try
{
System.Windows.IDataObject idataObject = System.Windows.Clipboard.GetDataObject();
if (idataObject != null)
{
CopyPaste.CopyAndPasteOperations.ProcessMoveMode(idataObject);
if (this.SelectedElement != null)
{
menuCommand.Enabled = CopyPaste.CopyAndPasteOperations.CanExecutePaste(this.SelectedElement, idataObject);
}
else if (this.SelectedRole != null)
{
menuCommand.Enabled = CopyPaste.CopyAndPasteOperations.CanExecutePaste(this.CurrentParentElement, idataObject);
}
else
{
menuCommand.Enabled = false;
}
}
}
catch
{
menuCommand.Enabled = false;
}
menuCommand.Visible = true;
}
/*
* private void OnStatusCut(object sender, System.EventArgs e)
* {
* System.ComponentModel.Design.MenuCommand menuCommand = (System.ComponentModel.Design.MenuCommand)sender;
* if (this.SelectedElement == null)
* {
* menuCommand.Enabled = false;
* return;
* }
*
* Collection<ModelElement> elements = new Collection<ModelElement>();
* elements.Add(this.SelectedElement);
*
* menuCommand.Enabled = CopyPaste.CopyAndPasteOperations.CanExecuteMove(elements);
* menuCommand.Visible = true;
*
* }
*/
private void OnStatusCopy(object sender, System.EventArgs e)
{
System.ComponentModel.Design.MenuCommand menuCommand = (System.ComponentModel.Design.MenuCommand)sender;
if (this.SelectedElement == null)
{
menuCommand.Enabled = false;
return;
}
if (this.SelectedElement is DomainType || this.SelectedElement is PropertyGridEditor ||
this.SelectedElement is CreditItem || this.SelectedElement is InformationItem ||
this.SelectedElement is EnumerationLiteral)
{
Collection <ModelElement> elements = new Collection <ModelElement>();
elements.Add(this.SelectedElement);
menuCommand.Enabled = CopyPaste.CopyAndPasteOperations.CanExecuteCopy(elements);
}
else
{
menuCommand.Enabled = false;
}
menuCommand.Visible = true;
}
/// <summary>
/// Adds the specified standard menu command to the menu.
/// </summary>
/// <param name="command">The System.ComponentModel.Design.MenuCommand to add.</param>
public void AddCommand(System.ComponentModel.Design.MenuCommand command)
{
commands.Add(command);
}
// Retire une command satndard du service
public override void RemoveCommand(System.ComponentModel.Design.MenuCommand command)
{
menuCommandService.RemoveCommand(command);
}
/// <summary>
/// Removes the specified standard menu command from the menu.
/// </summary>
/// <param name="command">The System.ComponentModel.Design.MenuCommand to remove.</param>
public void RemoveCommand(System.ComponentModel.Design.MenuCommand command)
{
commands.Remove(command);
}
