private KeySequence getIterationBinding() {
   final IBindingService bindingSvc =
       (IBindingService) PlatformUI.getWorkbench().getAdapter(IBindingService.class);
   TriggerSequence binding =
       bindingSvc.getBestActiveBindingFor(ITextEditorActionDefinitionIds.CONTENT_ASSIST_PROPOSALS);
   if (binding instanceof KeySequence) return (KeySequence) binding;
   return null;
 }
Example #2
0
  /**
   * @param commandId the command we want to know about
   * @return the 'best' key sequence that will activate the given command
   */
  public static KeySequence getCommandKeyBinding(String commandId) {
    final IBindingService bindingSvc =
        (IBindingService) PlatformUI.getWorkbench().getAdapter(IBindingService.class);
    TriggerSequence binding = bindingSvc.getBestActiveBindingFor(commandId);
    if (binding instanceof KeySequence) {
      return (KeySequence) binding;
    }

    return null;
  }
Example #3
0
  private static String getShowInMenuLabel() {
    IBindingService bindingService =
        (IBindingService) PlatformUI.getWorkbench().getAdapter(IBindingService.class);
    if (bindingService != null) {
      String keyBinding =
          bindingService.getBestActiveBindingFormattedFor(
              IWorkbenchCommandConstants.NAVIGATE_SHOW_IN_QUICK_MENU);
      if (keyBinding != null) return UIText.UIUtils_ShowInMenuLabel + '\t' + keyBinding;
    }

    return UIText.UIUtils_ShowInMenuLabel;
  }
 public static String getShortCutString(String proposalId) {
   if (proposalId != null) {
     IBindingService bindingService =
         (IBindingService) PlatformUI.getWorkbench().getAdapter(IBindingService.class);
     if (bindingService != null) {
       TriggerSequence[] activeBindingsFor = bindingService.getActiveBindingsFor(proposalId);
       if (activeBindingsFor.length > 0) {
         return activeBindingsFor[0].format();
       }
     }
   }
   return null;
 }
  private String getShowInMenuLabel() {
    String keyBinding = null;

    IBindingService bindingService =
        (IBindingService) PlatformUI.getWorkbench().getAdapter(IBindingService.class);
    if (bindingService != null)
      keyBinding =
          bindingService.getBestActiveBindingFormattedFor(
              IWorkbenchCommandConstants.NAVIGATE_SHOW_IN_QUICK_MENU);

    if (keyBinding == null) keyBinding = ""; // $NON-NLS-1$

    return "Sho&w In" + '\t' + keyBinding;
  }
  // 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 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);
  }
Example #8
0
 public synchronized void activateContext() {
   if (contextActivation == null) {
     contextActivation = contextService.activateContext(CONTROL_PANEL_CONTEXT_ID);
     bindingService.addBindingManagerListener(new BindingServiceListener());
     updateTriggerSequences();
   }
 }
  /*
   * (non-Javadoc)
   *
   * @see org.eclipse.ui.tests.harness.util.UITestCase#doTearDown()
   */
  protected void doTearDown() throws Exception {
    final IPreferenceStore store = WorkbenchPlugin.getDefault().getPreferenceStore();
    store.setValue(
        "org.eclipse.ui.commands",
        "<?xml version=\"1.0\" encoding=\"UTF-8\"?><org.eclipse.ui.commands><activeKeyConfiguration keyConfigurationId=\""
            + IBindingService.DEFAULT_DEFAULT_ACTIVE_SCHEME_ID
            + "\"/></org.eclipse.ui.commands>");
    IBindingService bindingService = (IBindingService) fWorkbench.getAdapter(IBindingService.class);

    // reset keybindings
    bindingService.readRegistryAndPreferences(null);
    final Scheme activeScheme =
        bindingService.getScheme(IBindingService.DEFAULT_DEFAULT_ACTIVE_SCHEME_ID);
    final Binding[] originalBindings = bindingService.getBindings();
    bindingService.savePreferences(activeScheme, originalBindings);
    super.doTearDown();
  }
Example #10
0
 protected TriggerSequence registerCommand(String commandId) {
   if (bindingService == null) return null;
   TriggerSequence key = bindingService.getBestActiveBindingFor(commandId);
   if (key != null) {
     triggerableCommands.put(key, commandId);
   }
   return key;
 }
Example #11
0
 public synchronized void deactivateContext() {
   if (contextActivation != null) {
     contextService.deactivateContext(contextActivation);
     contextActivation = null;
     bindingService.removeBindingManagerListener(new BindingServiceListener());
     updateTriggerSequences();
   }
 }
  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;
      }
    }
  }
  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);
    }
  }
  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;
      }
    }
  }
Example #16
0
  /**
   * @param event the key event to be checked
   * @param commandId the command to be checked
   * @return true if the given key event can trigger the passed command (and false otherwise).
   */
  public static boolean matchesKeybinding(KeyEvent event, String commandId) {
    final IBindingService bindingSvc =
        (IBindingService) PlatformUI.getWorkbench().getAdapter(IBindingService.class);
    TriggerSequence[] activeBindingsFor = bindingSvc.getActiveBindingsFor(commandId);

    for (TriggerSequence seq : activeBindingsFor) {
      if (seq instanceof KeySequence) {
        KeySequence keySequence = (KeySequence) seq;
        KeyStroke[] keyStrokes = keySequence.getKeyStrokes();

        for (KeyStroke keyStroke : keyStrokes) {

          if (keyStroke.getNaturalKey() == event.keyCode
              && (keyStroke.getModifierKeys() & event.stateMask) != 0) {

            return true;
          }
        }
      }
    }

    return false;
  }
  /**
   * Tests whether the preference store will be read automatically when a change to the preference
   * store is made.
   *
   * @throws ParseException If "ALT+SHIFT+Q A" cannot be parsed by KeySequence.
   */
  public final void testAutoLoad() throws ParseException {
    // Get the services.
    ICommandService commandService = (ICommandService) fWorkbench.getAdapter(ICommandService.class);
    IBindingService bindingService = (IBindingService) fWorkbench.getAdapter(IBindingService.class);
    bindingService.readRegistryAndPreferences(commandService);

    // Check the pre-conditions.
    final String emacsSchemeId = EMACS_SCHEME_ID;
    assertFalse(
        "The active scheme should be Emacs yet",
        emacsSchemeId.equals(bindingService.getActiveScheme().getId()));
    final KeySequence formalKeySequence = KeySequence.getInstance("ALT+SHIFT+Q A");
    final String commandId = "org.eclipse.ui.views.showView";
    Binding[] bindings = bindingService.getBindings();
    int i;
    for (i = 0; i < bindings.length; i++) {
      final Binding binding = bindings[i];
      if ((binding.getType() == Binding.USER)
          && (formalKeySequence.equals(binding.getTriggerSequence()))) {
        final ParameterizedCommand command = binding.getParameterizedCommand();
        final String actualCommandId = (command == null) ? null : command.getCommand().getId();
        assertFalse("The command should not yet be bound", commandId.equals(actualCommandId));
        break;
      }
    }
    assertEquals("There shouldn't be a matching command yet", bindings.length, i);

    // Modify the preference store.
    final IPreferenceStore store = WorkbenchPlugin.getDefault().getPreferenceStore();
    store.setValue(
        "org.eclipse.ui.commands",
        "<?xml version=\"1.0\" encoding=\"UTF-8\"?><org.eclipse.ui.commands><activeKeyConfiguration keyConfigurationId=\""
            + emacsSchemeId
            + "\"/><keyBinding commandId=\""
            + commandId
            + "\" contextId=\"org.eclipse.ui.contexts.window\" keyConfigurationId=\"org.eclipse.ui.defaultAcceleratorConfiguration\" keySequence=\""
            + formalKeySequence
            + "\"/></org.eclipse.ui.commands>");

    // Check that the values have changed.
    assertEquals(
        "The active scheme should now be Emacs",
        emacsSchemeId,
        bindingService.getActiveScheme().getId());
    bindings = bindingService.getBindings();
    for (i = 0; i < bindings.length; i++) {
      final Binding binding = bindings[i];
      if ((binding.getType() == Binding.USER)
          && (formalKeySequence.equals(binding.getTriggerSequence()))) {
        final ParameterizedCommand command = binding.getParameterizedCommand();
        final String actualCommandId = (command == null) ? null : command.getCommand().getId();
        assertEquals("The command should be bound to 'ALT+SHIFT+Q A'", commandId, actualCommandId);
        break;
      }
    }
    assertFalse("There should be a matching command now", (bindings.length == i));
  }
  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());
  }
Example #19
0
 private void updateTriggerSequence(String commandId, WritableValue value) {
   TriggerSequence[] sequences = bindingService.getActiveBindingsFor(commandId);
   value.setValue(sequences);
 }
Example #20
0
 /**
  * Returns the shortcut assigned to the sub menu or <code>null</code> if no short cut is assigned.
  *
  * @return the shortcut as a human readable string or <code>null</code>
  */
 private String getShortcutString() {
   IBindingService bindingService =
       (IBindingService) PlatformUI.getWorkbench().getAdapter(IBindingService.class);
   if (bindingService == null) return null;
   return bindingService.getBestActiveBindingFormattedFor(getActionDefinitionId());
 }
  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());
  }