// the 'paste' key binding overrides the 'redo' key binding on Windows
// platforms
public void testPasteAndRedoBindingEmacs() throws Exception {
ICommandService commandService = (ICommandService) fWorkbench.getAdapter(ICommandService.class);
IBindingService bindingService = (IBindingService) fWorkbench.getAdapter(IBindingService.class);
final Scheme emacsScheme = bindingService.getScheme(EMACS_SCHEME_ID);
assertNotNull(emacsScheme);
final Scheme defaultScheme =
bindingService.getScheme(IBindingService.DEFAULT_DEFAULT_ACTIVE_SCHEME_ID);
assertNotNull(defaultScheme);
final Binding[] originalBindings = bindingService.getBindings();
bindingService.savePreferences(emacsScheme, originalBindings);
ParameterizedCommand pasteCmd =
new ParameterizedCommand(
commandService.getCommand(IWorkbenchCommandConstants.EDIT_PASTE), null);
ParameterizedCommand redoCmd =
new ParameterizedCommand(
commandService.getCommand(IWorkbenchCommandConstants.EDIT_REDO), null);
final KeySequence keyCtrlY = KeySequence.getInstance("CTRL+Y");
final Binding pasteBinding = bindingService.getPerfectMatch(keyCtrlY);
assertNotNull(pasteBinding);
assertEquals(pasteCmd, pasteBinding.getParameterizedCommand());
assertEquals(EMACS_SCHEME_ID, pasteBinding.getSchemeId());
// reset the scheme
bindingService.savePreferences(defaultScheme, originalBindings);
final Binding redoBinding = bindingService.getPerfectMatch(keyCtrlY);
assertNotNull(redoBinding);
assertEquals(redoCmd, redoBinding.getParameterizedCommand());
assertEquals(IBindingService.DEFAULT_DEFAULT_ACTIVE_SCHEME_ID, redoBinding.getSchemeId());
}
public void testTwoHandlers() throws Exception {
createHandlerActivation(C1_ID, H1, new String[] {ISources.ACTIVE_CONTEXT_NAME});
createHandlerActivation(
C2_ID, H2, new String[] {ISources.ACTIVE_CONTEXT_NAME, ISources.ACTIVE_ACTION_SETS_NAME});
Command cmd = commandService.getCommand(CMD_ID);
assertTrue("Command should be defined", cmd.isDefined());
assertFalse("Should not be handled yet", cmd.isHandled());
IContextActivation activationC1 = activateContext(C1_ID);
assertTrue("Should definitely be handled", cmd.isHandled());
ActTestHandler handler1 = (ActTestHandler) testHandlers.get(H1);
int count1 = handler1.executionCount;
cmd.executeWithChecks(new ExecutionEvent());
assertEquals("The handler count should be incremented", count1 + 1, handler1.executionCount);
activateContext(C2_ID);
assertTrue("Should still be handled", cmd.isHandled());
ActTestHandler handler2 = (ActTestHandler) testHandlers.get(H2);
int count2 = handler2.executionCount;
count1 = handler1.executionCount;
cmd.executeWithChecks(new ExecutionEvent());
assertEquals("The handler1 count should not be incremented", count1, handler1.executionCount);
assertEquals("The handler2 count should be incremented", count2 + 1, handler2.executionCount);
contextService.deactivateContext(activationC1);
assertTrue("Will still be handled", cmd.isHandled());
}
void createCommand(String commandId, Map parameters) {
if (commandId == null) {
WorkbenchPlugin.log(
"Unable to create menu item \""
+ getId() //$NON-NLS-1$
+ "\", no command id"); //$NON-NLS-1$
return;
}
Command cmd = commandService.getCommand(commandId);
if (!cmd.isDefined()) {
WorkbenchPlugin.log(
"Unable to create menu item \""
+ getId() //$NON-NLS-1$
+ "\", command \""
+ commandId
+ "\" not defined"); //$NON-NLS-1$ //$NON-NLS-2$
return;
}
if (parameters == null || parameters.size() == 0) {
command = new ParameterizedCommand(cmd, null);
return;
}
try {
ArrayList parmList = new ArrayList();
Iterator i = parameters.entrySet().iterator();
while (i.hasNext()) {
Map.Entry entry = (Map.Entry) i.next();
String parmName = (String) entry.getKey();
IParameter parm;
parm = cmd.getParameter(parmName);
if (parm == null) {
WorkbenchPlugin.log(
"Unable to create menu item \""
+ getId() //$NON-NLS-1$
+ "\", parameter \""
+ parmName
+ "\" for command \"" //$NON-NLS-1$ //$NON-NLS-2$
+ commandId
+ "\" is not defined"); //$NON-NLS-1$
return;
}
parmList.add(new Parameterization(parm, (String) entry.getValue()));
}
command =
new ParameterizedCommand(
cmd, (Parameterization[]) parmList.toArray(new Parameterization[parmList.size()]));
} catch (NotDefinedException e) {
// this shouldn't happen as we checked for !defined, but we
// won't take the chance
WorkbenchPlugin.log(
"Failed to create menu item " //$NON-NLS-1$
+ getId(),
e);
}
}
@Override
public void execute(String newText) throws CoreException {
if (newText.isEmpty()) {
if (getModel().getText() != null) {
EnquiryTranslationRemoveCommand removeCmd = new EnquiryTranslationRemoveCommand(getModel());
removeCmd.execute(newText);
}
return;
}
if (newText.equals(getModel().getText())) {
// do nothing if text is the same.
return;
}
IEditorPart editorPart = getActiveEditorPart();
if (editorPart != null) {
// Extract useful parameters needed for the command
IWorkbenchPartSite site = editorPart.getSite();
// Invoke the command
IHandlerService handlerService = (IHandlerService) site.getService(IHandlerService.class);
ICommandService commandService = (ICommandService) site.getService(ICommandService.class);
CommandStack commandStack = (CommandStack) editorPart.getAdapter(CommandStack.class);
try {
// Get the command and assign values to parameters
Command command = commandService.getCommand(EDIT_COMMAND_ID);
Parameterization parameter = new Parameterization(command.getParameter("text"), newText);
ParameterizedCommand parmCommand =
new ParameterizedCommand(command, new Parameterization[] {parameter});
// Prepare the evaluation context
IEvaluationContext ctx = handlerService.getCurrentState();
ctx.addVariable("model", getModel());
ctx.addVariable("commandStack", commandStack);
// Execute the command
handlerService.executeCommandInContext(parmCommand, null, ctx);
} catch (Exception ex) {
IStatus status =
new Status(
IStatus.ERROR,
Activator.PLUGIN_ID,
"Error while executing command to update translation",
ex);
throw new CoreException(status);
}
} else {
/** @TODO log warn no active editorPart, should never occur */
}
}
/** {@inheritDoc} */
@Override
public Object execute(ExecutionEvent event) throws ExecutionException {
StructuredSelection selection =
(StructuredSelection) HandlerUtil.getCurrentSelectionChecked(event);
AbstractRootEditor rootEditor = (AbstractRootEditor) HandlerUtil.getActiveEditor(event);
RepositoryDefinition repositoryDefinition =
rootEditor.getInputDefinition().getRepositoryDefinition();
Object selectedObject = selection.getFirstElement();
ExceptionSensorData dataToNavigateTo = null;
if (selectedObject instanceof ExceptionSensorData) {
dataToNavigateTo = (ExceptionSensorData) selectedObject;
} else if (selectedObject instanceof InvocationSequenceData) {
List<ExceptionSensorData> exceptions =
((InvocationSequenceData) selectedObject).getExceptionSensorDataObjects();
if ((null != exceptions) && !exceptions.isEmpty()) {
for (ExceptionSensorData exSensorData : exceptions) {
if (0 != exSensorData.getMethodIdent()) {
dataToNavigateTo = exSensorData;
break;
}
}
}
}
if (null != dataToNavigateTo) {
ExceptionSensorData exceptionSensorData = dataToNavigateTo;
// exit if the object does not carry the methodIdent
if (null == exceptionSensorData.getThrowableType()) {
return null;
}
InputDefinition inputDefinition =
getInputDefinition(repositoryDefinition, exceptionSensorData);
// open the view via command
IHandlerService handlerService =
(IHandlerService) PlatformUI.getWorkbench().getService(IHandlerService.class);
ICommandService commandService =
(ICommandService) PlatformUI.getWorkbench().getService(ICommandService.class);
Command command = commandService.getCommand(OpenViewHandler.COMMAND);
ExecutionEvent executionEvent = handlerService.createExecutionEvent(command, new Event());
IEvaluationContext context = (IEvaluationContext) executionEvent.getApplicationContext();
context.addVariable(OpenViewHandler.INPUT, inputDefinition);
try {
command.executeWithChecks(executionEvent);
} catch (NotDefinedException | NotEnabledException | NotHandledException e) {
throw new ExecutionException("Error opening the exception type view.", e);
}
}
return null;
}
public static boolean isShowPlanNames() {
ICommandService commandService =
(ICommandService)
PlatformUI.getWorkbench().getActiveWorkbenchWindow().getService(ICommandService.class);
Command command = commandService.getCommand("at.ac.tuwien.ieg.asbruedit.show-planname-toggle");
State state = command.getState("org.eclipse.ui.commands.toggleState");
boolean isToggled = (Boolean) state.getValue();
return isToggled;
}
public void run() {
ICommandService commandService =
(ICommandService) this.cheatSheetCatalogView.getSite().getService(ICommandService.class);
IStructuredSelection structuredSelection =
(IStructuredSelection) this.cheatSheetCatalogView.getViewer().getSelection();
CheatSheetReference cheatSheetReference =
(CheatSheetReference) structuredSelection.getFirstElement();
if (cheatSheetReference.getUrl().startsWith("platform:/")) {
Command command = commandService.getCommand("org.eclipse.ui.cheatsheets.openCheatSheet");
Map<String, String> map = new HashMap<String, String>();
map.put("cheatSheetId", cheatSheetReference.getUrl().substring("platform:/".length()));
try {
command.executeWithChecks(new ExecutionEvent(command, map, null, null));
} catch (Exception e) {
ErrorDialog errorDialog =
new ErrorDialog(
"Impossible to open Cheat Sheet",
"An error occured while trying to open cheat sheet.",
e);
errorDialog.open();
}
} else {
Command command = commandService.getCommand("org.eclipse.ui.cheatsheets.openCheatSheetURL");
Map<String, String> map = new HashMap<String, String>();
map.put("cheatSheetId", cheatSheetReference.getId());
map.put("name", cheatSheetReference.getName());
map.put("url", cheatSheetReference.getUrl());
try {
command.executeWithChecks(new ExecutionEvent(command, map, null, null));
} catch (Exception e) {
ErrorDialog errorDialog =
new ErrorDialog(
"Impossible to open Cheat Sheet",
"An error occured while trying to open cheat sheet.",
e);
errorDialog.open();
}
}
}
/** Alert whoever is listening that a new OPIShell has been created. */
private static void sendUpdateCommand() {
IServiceLocator serviceLocator = PlatformUI.getWorkbench();
ICommandService commandService =
(ICommandService) serviceLocator.getService(ICommandService.class);
try {
Command command = commandService.getCommand(OPI_SHELLS_CHANGED_ID);
command.executeWithChecks(new ExecutionEvent());
} catch (ExecutionException
| NotHandledException
| NotEnabledException
| NotDefinedException e) {
log.log(Level.WARNING, "Failed to send OPI shells changed command", e);
}
}
public void testForNegativeNumber() throws Exception {
String c5_id = C_PREFIX + ISources.ACTIVE_MENU_NAME;
String h5 = C_PREFIX + "h5";
createHandlerActivation(
c5_id, h5, new String[] {ISources.ACTIVE_CONTEXT_NAME, ISources.ACTIVE_MENU_NAME});
createHandlerActivation(C1_ID, H1, new String[] {ISources.ACTIVE_CONTEXT_NAME});
Command cmd = commandService.getCommand(CMD_ID);
activateContext(C1_ID);
activateContext(c5_id);
assertHandlerIsExecuted(cmd, h5);
}
public void testAboutBindingIn3x() throws Exception {
ICommandService commandService = (ICommandService) fWorkbench.getAdapter(ICommandService.class);
IBindingService bindingService = (IBindingService) fWorkbench.getAdapter(IBindingService.class);
final Scheme activeScheme = bindingService.getActiveScheme();
ParameterizedCommand aboutCmd =
new ParameterizedCommand(
commandService.getCommand(IWorkbenchCommandConstants.HELP_ABOUT), null);
ParameterizedCommand activateEditorCmd =
new ParameterizedCommand(
commandService.getCommand(IWorkbenchCommandConstants.WINDOW_ACTIVATE_EDITOR), null);
final KeySequence keyF12 = KeySequence.getInstance("F12");
final Binding editorBinding = bindingService.getPerfectMatch(keyF12);
assertNotNull(editorBinding);
assertEquals(activateEditorCmd, editorBinding.getParameterizedCommand());
EBindingService ebs = (EBindingService) fWorkbench.getService(EBindingService.class);
HashMap<String, String> attrs = new HashMap<String, String>();
attrs.put(EBindingService.TYPE_ATTR_TAG, "user");
final Binding localAboutBinding =
ebs.createBinding(keyF12, aboutCmd, IContextService.CONTEXT_ID_WINDOW, attrs);
assertEquals(Binding.USER, localAboutBinding.getType());
final Binding[] bindings = bindingService.getBindings();
Binding[] added = new Binding[bindings.length + 1];
System.arraycopy(bindings, 0, added, 0, bindings.length);
added[bindings.length] = localAboutBinding;
bindingService.savePreferences(activeScheme, added);
final Binding secondMatch = bindingService.getPerfectMatch(keyF12);
// fails
assertNotNull(secondMatch);
assertEquals(aboutCmd, secondMatch.getParameterizedCommand());
}
public final void testBindingTransform() throws Exception {
ICommandService commandService = (ICommandService) fWorkbench.getAdapter(ICommandService.class);
IBindingService bindingService = (IBindingService) fWorkbench.getAdapter(IBindingService.class);
ParameterizedCommand addWS =
new ParameterizedCommand(
commandService.getCommand("org.eclipse.ui.navigate.addToWorkingSet"), null);
KeySequence m18w = KeySequence.getInstance("M1+8 W");
KeySequence m28w = KeySequence.getInstance("M2+8 W");
boolean foundDeleteMarker = false;
int numOfMarkers = 0;
Binding[] bindings = bindingService.getBindings();
for (int i = 0; i < bindings.length; i++) {
final Binding binding = bindings[i];
if (binding.getType() == Binding.SYSTEM) {
String platform = binding.getPlatform();
int idx = (platform == null ? -1 : platform.indexOf(','));
assertEquals(binding.toString(), -1, idx);
if (addWS.equals(binding.getParameterizedCommand())) {
if (m18w.equals(binding.getTriggerSequence())) {
numOfMarkers++;
assertNull(m18w.format(), binding.getPlatform());
} else if (m28w.equals(binding.getTriggerSequence())) {
numOfMarkers++;
assertTrue(
platform,
Util.WS_CARBON.equals(platform)
|| Util.WS_COCOA.equals(platform)
|| Util.WS_GTK.equals(platform)
|| Util.WS_WIN32.equals(platform));
}
} else if (binding.getParameterizedCommand() == null
&& m18w.equals(binding.getTriggerSequence())) {
assertTrue(
platform,
Util.WS_CARBON.equals(platform)
|| Util.WS_COCOA.equals(platform)
|| Util.WS_GTK.equals(platform)
|| Util.WS_WIN32.equals(platform));
numOfMarkers++;
foundDeleteMarker = true;
}
}
}
assertEquals(3, numOfMarkers);
assertTrue("Unable to find delete marker", foundDeleteMarker);
TriggerSequence[] activeBindingsFor = bindingService.getActiveBindingsFor(addWS);
assertEquals(1, activeBindingsFor.length);
}
/*
* (non-Javadoc)
*
* @see org.eclipse.ui.tests.harness.util.UITestCase#doSetUp()
*/
protected void doSetUp() throws Exception {
for (int i = 0; i < CREATE_CONTEXTS.length; i++) {
final String[] contextInfo = CREATE_CONTEXTS[i];
final Context context = contextService.getContext(contextInfo[0]);
if (!context.isDefined()) {
context.define(contextInfo[1], contextInfo[2], contextInfo[3]);
}
}
Command cmd = commandService.getCommand(CMD_ID);
if (!cmd.isDefined()) {
Category cat = commandService.getCategory(CATEGORY_ID);
cmd.define("Test Handler", "Test handler activation", cat);
}
}
@Override
public void execute(String newText) throws CoreException {
IEditorPart editorPart = getActiveEditorPart();
if (editorPart != null) {
// Extract useful parameters needed for the command
IWorkbenchPartSite site = editorPart.getSite();
// Invoke the command
IHandlerService handlerService = (IHandlerService) site.getService(IHandlerService.class);
ICommandService commandService = (ICommandService) site.getService(ICommandService.class);
if (editorPart instanceof VersionMultiPageEditor) {
VersionMultiPageEditor vEditor = (VersionMultiPageEditor) editorPart;
EditingDomain editingDomain = vEditor.getVersionFormEditor().getEditingDomain();
CommandStack commandStack = editingDomain.getCommandStack();
try {
// Get the command and assign values to parameters
Command command = commandService.getCommand(getCommandId());
ParameterizedCommand parmCommand =
new ParameterizedCommand(command, new Parameterization[] {});
// Prepare the evaluation context
IEvaluationContext ctx = handlerService.getCurrentState();
ctx.addVariable("model", getModel());
ctx.addVariable("commandStack", commandStack);
ctx.addVariable("editingDomain", editingDomain);
// Execute the command
handlerService.executeCommandInContext(parmCommand, null, ctx);
} catch (Exception ex) {
IStatus status =
new Status(
IStatus.ERROR,
VersionEditorActivator.PLUGIN_ID,
"Error while executing command to remove translation",
ex);
throw new CoreException(status);
}
}
} else {
/** @TODO log warn no active editorPart, should never occur */
}
}
public static void executeCommand(IViewSite site, String command) {
ICommandService cmdService = (ICommandService) site.getService(ICommandService.class);
IHandlerService hdlService = (IHandlerService) site.getService(IHandlerService.class);
Command cmd = cmdService.getCommand(command);
try {
hdlService.executeCommand(cmd.getId(), null);
} catch (ExecutionException e) {
e.printStackTrace();
} catch (NotDefinedException e) {
e.printStackTrace();
} catch (NotEnabledException e) {
e.printStackTrace();
} catch (NotHandledException e) {
e.printStackTrace();
}
}
private void openSample(String file) throws CommandException {
IHandlerService handlerService =
(IHandlerService) getIntroSite().getService(IHandlerService.class);
ICommandService commandService =
(ICommandService) getIntroSite().getService(ICommandService.class);
Command command =
commandService.getCommand(
"name.abuchen.portfolio.ui.commands.openSampleCommand"); //$NON-NLS-1$
Map<String, String> parameters = new HashMap<String, String>();
parameters.put("name.abuchen.portfolio.ui.param.sample", file); // $NON-NLS-1$
ParameterizedCommand parameterized = ParameterizedCommand.generateCommand(command, parameters);
handlerService.executeCommand(parameterized, null);
PlatformUI.getWorkbench().getIntroManager().closeIntro(this);
}
public void testModifierNotApplied() throws Exception {
ICommandService commandService = (ICommandService) fWorkbench.getAdapter(ICommandService.class);
IBindingService bindingService = (IBindingService) fWorkbench.getAdapter(IBindingService.class);
ParameterizedCommand exportCmd =
new ParameterizedCommand(commandService.getCommand("org.eclipse.ui.file.export"), null);
Binding[] bindings = bindingService.getBindings();
for (int i = 0; i < bindings.length; i++) {
final Binding binding = bindings[i];
if (binding.getType() != Binding.SYSTEM) continue;
if (exportCmd.equals(binding.getParameterizedCommand())) {
// make sure the modifier is NOT applied
assertEquals(KeySequence.getInstance("M1+8 E"), binding.getTriggerSequence());
break;
}
}
}
/**
* @throws ExecutionException
* @throws NotDefinedException
* @throws NotEnabledException
* @throws NotHandledException
*/
private void doTestForBreak()
throws ExecutionException, NotDefinedException, NotEnabledException, NotHandledException {
Command cmd = commandService.getCommand(CMD_ID);
assertTrue("Command should be defined", cmd.isDefined());
assertFalse("Should not be handled yet", cmd.isHandled());
IContextActivation c1 = activateContext(C1_ID);
IContextActivation c2 = activateContext(C2_ID);
IContextActivation c3 = activateContext(C3_ID);
assertTrue("Should still be handled", cmd.isHandled());
assertHandlerIsExecuted(cmd, H3);
contextService.deactivateContext(c3);
contextService.deactivateContext(c2);
contextService.deactivateContext(c1);
}
public final void testSinglePlatform() throws Exception {
// Get the services.
ICommandService commandService = (ICommandService) fWorkbench.getAdapter(ICommandService.class);
IBindingService bindingService = (IBindingService) fWorkbench.getAdapter(IBindingService.class);
ParameterizedCommand about =
new ParameterizedCommand(
commandService.getCommand("org.eclipse.ui.help.aboutAction"), null);
KeySequence m18A = KeySequence.getInstance("M1+8 A");
KeySequence m18B = KeySequence.getInstance("M1+8 B");
int numAboutBindings = 0;
Binding[] bindings = bindingService.getBindings();
for (int i = 0; i < bindings.length; i++) {
final Binding binding = bindings[i];
if (binding.getType() == Binding.SYSTEM) {
String platform = binding.getPlatform();
int idx = (platform == null ? -1 : platform.indexOf(','));
assertEquals(binding.toString(), -1, idx);
if (about.equals(binding.getParameterizedCommand())) {
if (m18A.equals(binding.getTriggerSequence())) {
numAboutBindings++;
assertNull("M+8 A", binding.getPlatform());
} else if (m18B.equals(binding.getTriggerSequence())) {
numAboutBindings++;
// assertEquals(Util.WS_CARBON, binding.getPlatform());
// temp work around for honouring carbon bindings
assertTrue(
"failure for platform: " + binding.getPlatform(),
Util.WS_CARBON.equals(binding.getPlatform())
|| Util.WS_COCOA.equals(binding.getPlatform()));
}
}
}
}
if (Util.WS_CARBON.equals(SWT.getPlatform()) || Util.WS_COCOA.equals(SWT.getPlatform())) {
assertEquals(2, numAboutBindings);
} else {
assertEquals(1, numAboutBindings);
}
}
private void addSave(IMenuManager menu) {
ICommandService commandService =
(ICommandService) fContainer.getWorkbenchPart().getSite().getService(ICommandService.class);
final Command command = commandService.getCommand(IWorkbenchCommandConstants.FILE_SAVE);
final IHandler handler = command.getHandler();
if (handler != null) {
if (fSaveContributionItem == null) {
fSaveContributionItem =
new CommandContributionItem(
new CommandContributionItemParameter(
fContainer.getWorkbenchPart().getSite(),
null,
command.getId(),
CommandContributionItem.STYLE_PUSH));
}
// save is an editable dependent action, ie add only when edit
// is possible
if (handler.isHandled() && getSourceViewer().isEditable()) menu.add(fSaveContributionItem);
}
}
public void testBasicHandler() throws Exception {
createHandlerActivation(C1_ID, H1, new String[] {ISources.ACTIVE_CONTEXT_NAME});
Command cmd = commandService.getCommand(CMD_ID);
assertTrue("Command should be defined", cmd.isDefined());
assertFalse("Should not be handled yet", cmd.isHandled());
IContextActivation activationC1 = activateContext(C1_ID);
assertTrue("Should definitely be handled", cmd.isHandled());
ActTestHandler handler1 = (ActTestHandler) testHandlers.get(H1);
int count = handler1.executionCount;
cmd.executeWithChecks(new ExecutionEvent());
assertEquals("The handler count should be correct", count + 1, handler1.executionCount);
contextService.deactivateContext(activationC1);
assertFalse("Should not be handled", cmd.isHandled());
}
@Override
public void launch(final IEditorPart editor, final String mode) {
assert mode.equals("run"); // $NON-NLS-1$
final IWorkbenchPart workbenchPart = UIAccess.getActiveWorkbenchPart(false);
final IWorkbenchPartSite site = workbenchPart.getSite();
if (site != null) {
final IHandlerService handlerService =
(IHandlerService) site.getService(IHandlerService.class);
final ICommandService commandService =
(ICommandService) site.getService(ICommandService.class);
final Map<String, String> parameters = new HashMap<String, String>();
parameters.put(RCodeLaunching.FILE_COMMAND_ID_PARAMTER_ID, fFileCommandId);
final Command command =
commandService.getCommand(
!fGotoConsole
? RCodeLaunching.RUN_FILEVIACOMMAND_COMMAND_ID
: RCodeLaunching.RUN_FILEVIACOMMAND_GOTOCONSOLE_COMMAND_ID);
final ExecutionEvent executionEvent =
new ExecutionEvent(command, parameters, null, handlerService.getCurrentState());
if (!editor.equals(HandlerUtil.getActivePart(executionEvent))) {
LaunchShortcutUtil.handleUnsupportedExecution(executionEvent);
return;
}
try {
command.executeWithChecks(executionEvent);
} catch (final ExecutionException e) {
LaunchShortcutUtil.handleRLaunchException(
e, RLaunchingMessages.RScriptLaunch_error_message, executionEvent);
} catch (final NotDefinedException e) {
LaunchShortcutUtil.handleUnsupportedExecution(executionEvent);
} catch (final NotEnabledException e) {
LaunchShortcutUtil.handleUnsupportedExecution(executionEvent);
} catch (final NotHandledException e) {
LaunchShortcutUtil.handleUnsupportedExecution(executionEvent);
}
}
}
public void testModifierWithPlatform() throws Exception {
ICommandService commandService = (ICommandService) fWorkbench.getAdapter(ICommandService.class);
IBindingService bindingService = (IBindingService) fWorkbench.getAdapter(IBindingService.class);
ParameterizedCommand importCmd =
new ParameterizedCommand(commandService.getCommand("org.eclipse.ui.file.import"), null);
Binding[] bindings = bindingService.getBindings();
int numOfMarkers = 0;
for (int i = 0; i < bindings.length; i++) {
final Binding binding = bindings[i];
if (binding.getType() != Binding.SYSTEM) continue;
if (importCmd.equals(binding.getParameterizedCommand())) {
// make sure the modifier is applied
assertEquals(KeySequence.getInstance("M2+8 I"), binding.getTriggerSequence());
numOfMarkers++;
}
}
// only one binding, if the platform matches
assertEquals(numOfMarkers, 1);
}
public void testDifferentPlatform() throws Exception {
ICommandService commandService = (ICommandService) fWorkbench.getAdapter(ICommandService.class);
IBindingService bindingService = (IBindingService) fWorkbench.getAdapter(IBindingService.class);
ParameterizedCommand backCmd =
new ParameterizedCommand(commandService.getCommand("org.eclipse.ui.navigate.back"), null);
Binding[] bindings = bindingService.getBindings();
for (int i = 0; i < bindings.length; i++) {
final Binding binding = bindings[i];
if (binding.getType() != Binding.SYSTEM) continue;
if (backCmd.equals(binding.getParameterizedCommand())) {
// make sure the modifier is NOT applied
// this will fail on Photon (but Paul thinks we'll never run the
// test suite on that platform :-)
assertEquals(KeySequence.getInstance("M1+8 Q"), binding.getTriggerSequence());
// and the platform should be null
assertNull(binding.getPlatform());
break;
}
}
}
public final void setActionDefinitionId(final String id) {
// Get the old values.
final boolean oldChecked = isChecked();
final String oldDescription = getDescription();
final boolean oldEnabled = isEnabled();
final boolean oldHandled = isHandled();
final ImageDescriptor oldDefaultImage = getImageDescriptor();
final ImageDescriptor oldDisabledImage = getDisabledImageDescriptor();
final ImageDescriptor oldHoverImage = getHoverImageDescriptor();
final String oldText = getText();
// Update the command.
final Command oldBaseCommand = command.getCommand();
oldBaseCommand.removeCommandListener(commandListener);
final ICommandService commandService =
(ICommandService) serviceLocator.getService(ICommandService.class);
final Command newBaseCommand = commandService.getCommand(id);
command = new ParameterizedCommand(newBaseCommand, null);
newBaseCommand.addCommandListener(commandListener);
// Get the new values.
final boolean newChecked = isChecked();
final String newDescription = getDescription();
final boolean newEnabled = isEnabled();
final boolean newHandled = isHandled();
final ImageDescriptor newDefaultImage = getImageDescriptor();
final ImageDescriptor newDisabledImage = getDisabledImageDescriptor();
final ImageDescriptor newHoverImage = getHoverImageDescriptor();
final String newText = getText();
// Fire property change events, as necessary.
if (newChecked != oldChecked) {
if (oldChecked) {
firePropertyChange(IAction.CHECKED, Boolean.TRUE, Boolean.FALSE);
} else {
firePropertyChange(IAction.CHECKED, Boolean.FALSE, Boolean.TRUE);
}
}
if (!Util.equals(oldDescription, newDescription)) {
firePropertyChange(IAction.DESCRIPTION, oldDescription, newDescription);
firePropertyChange(IAction.TOOL_TIP_TEXT, oldDescription, newDescription);
}
if (newEnabled != oldEnabled) {
if (oldEnabled) {
firePropertyChange(IAction.ENABLED, Boolean.TRUE, Boolean.FALSE);
} else {
firePropertyChange(IAction.ENABLED, Boolean.FALSE, Boolean.TRUE);
}
}
if (newHandled != oldHandled) {
if (oldHandled) {
firePropertyChange(IAction.HANDLED, Boolean.TRUE, Boolean.FALSE);
} else {
firePropertyChange(IAction.HANDLED, Boolean.FALSE, Boolean.TRUE);
}
}
if (!Util.equals(oldDefaultImage, newDefaultImage)) {
firePropertyChange(IAction.IMAGE, oldDefaultImage, newDefaultImage);
}
if (!Util.equals(oldDisabledImage, newDisabledImage)) {
firePropertyChange(IAction.IMAGE, oldDisabledImage, newDisabledImage);
}
if (!Util.equals(oldHoverImage, newHoverImage)) {
firePropertyChange(IAction.IMAGE, oldHoverImage, newHoverImage);
}
if (!Util.equals(oldText, newText)) {
firePropertyChange(IAction.TEXT, oldText, newText);
}
}
public void testAboutBinding() throws Exception {
ICommandService commandService = (ICommandService) fWorkbench.getAdapter(ICommandService.class);
IBindingService bindingService = (IBindingService) fWorkbench.getAdapter(IBindingService.class);
final Scheme activeScheme = bindingService.getActiveScheme();
final Binding[] originalBindings = bindingService.getBindings();
ParameterizedCommand aboutCmd =
new ParameterizedCommand(
commandService.getCommand(IWorkbenchCommandConstants.HELP_ABOUT), null);
ParameterizedCommand activateEditorCmd =
new ParameterizedCommand(
commandService.getCommand(IWorkbenchCommandConstants.WINDOW_ACTIVATE_EDITOR), null);
final KeySequence keyF12 = KeySequence.getInstance("F12");
final KeySequence keyAltCtrlShiftI = KeySequence.getInstance("ALT+CTRL+SHIFT+I");
final Binding editorBinding = bindingService.getPerfectMatch(keyF12);
assertNotNull(editorBinding);
assertEquals(activateEditorCmd, editorBinding.getParameterizedCommand());
EBindingService ebs = (EBindingService) fWorkbench.getService(EBindingService.class);
HashMap<String, String> attrs = new HashMap<String, String>();
attrs.put(EBindingService.TYPE_ATTR_TAG, "user");
final Binding localAboutBinding =
ebs.createBinding(keyF12, aboutCmd, IContextService.CONTEXT_ID_WINDOW, attrs);
assertEquals(Binding.USER, localAboutBinding.getType());
// test unbinding a system binding and adding a user binding (same
// triggers and context)
final Binding[] bindings = originalBindings;
Binding[] added = new Binding[bindings.length + 2];
System.arraycopy(bindings, 0, added, 0, bindings.length);
Binding del =
new KeyBinding(
keyF12,
null,
IBindingService.DEFAULT_DEFAULT_ACTIVE_SCHEME_ID,
IContextService.CONTEXT_ID_WINDOW,
null,
null,
null,
Binding.USER);
added[bindings.length] = del;
added[bindings.length + 1] = localAboutBinding;
bindingService.savePreferences(activeScheme, added);
// the match should be the user binding that we just added
final Binding secondMatch = bindingService.getPerfectMatch(keyF12);
assertNotNull(secondMatch);
assertEquals(aboutCmd, secondMatch.getParameterizedCommand());
// go back to the defaults
bindingService.savePreferences(activeScheme, originalBindings);
final Binding thirdMatch = bindingService.getPerfectMatch(keyF12);
assertNotNull(thirdMatch);
assertEquals(activateEditorCmd, thirdMatch.getParameterizedCommand());
// try assigning alt-ctrl-shift-i (no other binding uses this for this
// context) to the 'about' command
final Binding localAboutBinding1 =
ebs.createBinding(keyAltCtrlShiftI, aboutCmd, IContextService.CONTEXT_ID_WINDOW, attrs);
assertEquals(Binding.USER, localAboutBinding1.getType());
Binding[] added1 = new Binding[bindings.length + 1];
System.arraycopy(bindings, 0, added1, 0, bindings.length);
added1[bindings.length] = localAboutBinding1;
bindingService.savePreferences(activeScheme, added1);
final Binding fourthMatch = bindingService.getPerfectMatch(keyAltCtrlShiftI);
assertNotNull(fourthMatch);
assertEquals(aboutCmd, fourthMatch.getParameterizedCommand());
}
public void testAboutBindingEmacs() throws Exception {
ICommandService commandService = (ICommandService) fWorkbench.getAdapter(ICommandService.class);
IBindingService bindingService = (IBindingService) fWorkbench.getAdapter(IBindingService.class);
final Scheme emacsScheme = bindingService.getScheme(EMACS_SCHEME_ID);
assertNotNull(emacsScheme);
final Binding[] originalBindings = bindingService.getBindings();
bindingService.savePreferences(emacsScheme, originalBindings);
ParameterizedCommand findAndReplaceCmd =
new ParameterizedCommand(
commandService.getCommand(IWorkbenchCommandConstants.EDIT_FIND_AND_REPLACE), null);
ParameterizedCommand aboutCmd =
new ParameterizedCommand(
commandService.getCommand(IWorkbenchCommandConstants.HELP_ABOUT), null);
final KeySequence keyAltR = KeySequence.getInstance("ALT+R");
final KeySequence keyAltCtrlShiftI = KeySequence.getInstance("ALT+CTRL+SHIFT+I");
final Binding findAndReplaceBinding = bindingService.getPerfectMatch(keyAltR);
assertNotNull(findAndReplaceBinding);
assertEquals(findAndReplaceCmd, findAndReplaceBinding.getParameterizedCommand());
assertEquals(EMACS_SCHEME_ID, findAndReplaceBinding.getSchemeId());
EBindingService ebs = (EBindingService) fWorkbench.getService(EBindingService.class);
HashMap<String, String> attrs = new HashMap<String, String>();
attrs.put(EBindingService.TYPE_ATTR_TAG, "user");
attrs.put(EBindingService.SCHEME_ID_ATTR_TAG, EMACS_SCHEME_ID);
final Binding localAboutBinding =
ebs.createBinding(keyAltR, aboutCmd, IContextService.CONTEXT_ID_WINDOW, attrs);
assertNotNull(localAboutBinding);
assertEquals(Binding.USER, localAboutBinding.getType());
assertEquals(EMACS_SCHEME_ID, localAboutBinding.getSchemeId());
final Binding[] bindings = originalBindings;
Binding[] added = new Binding[bindings.length + 2];
System.arraycopy(bindings, 0, added, 0, bindings.length);
Binding del =
new KeyBinding(
keyAltR,
null,
EMACS_SCHEME_ID,
IContextService.CONTEXT_ID_WINDOW,
null,
null,
null,
Binding.USER);
added[bindings.length] = del;
added[bindings.length + 1] = localAboutBinding;
bindingService.savePreferences(emacsScheme, added);
// the match should be the user binding that we just added
final Binding secondMatch = bindingService.getPerfectMatch(keyAltR);
assertNotNull(secondMatch);
assertEquals(aboutCmd, secondMatch.getParameterizedCommand());
// go back to the defaults
bindingService.savePreferences(emacsScheme, originalBindings);
final Binding thirdMatch = bindingService.getPerfectMatch(keyAltR);
assertNotNull(thirdMatch);
assertEquals(findAndReplaceCmd, thirdMatch.getParameterizedCommand());
// try assigning alt-ctrl-shift-i (no other binding uses this for this
// context) to the 'about' command
final Binding localAboutBinding1 =
ebs.createBinding(keyAltCtrlShiftI, aboutCmd, IContextService.CONTEXT_ID_WINDOW, attrs);
assertNotNull(localAboutBinding1);
assertEquals(Binding.USER, localAboutBinding1.getType());
assertEquals(EMACS_SCHEME_ID, localAboutBinding.getSchemeId());
Binding[] added1 = new Binding[bindings.length + 1];
System.arraycopy(bindings, 0, added1, 0, bindings.length);
added1[bindings.length] = localAboutBinding1;
bindingService.savePreferences(emacsScheme, added1);
final Binding fourthMatch = bindingService.getPerfectMatch(keyAltCtrlShiftI);
assertNotNull(fourthMatch);
assertEquals(aboutCmd, fourthMatch.getParameterizedCommand());
assertEquals(EMACS_SCHEME_ID, fourthMatch.getSchemeId());
}
private void defineCommand(final String commandId, final String name, AbstractHandler handler) {
Command command = commandService.getCommand(commandId);
command.define(name, null, autogeneratedCategory);
command.setHandler(handler);
}
