public void registerCommands(CompilationUnitEditor editor) {
    IWorkbench workbench = PlatformUI.getWorkbench();
    ICommandService commandService = (ICommandService) workbench.getAdapter(ICommandService.class);
    IHandlerService handlerService = (IHandlerService) workbench.getAdapter(IHandlerService.class);
    if (commandService == null || handlerService == null) {
      return;
    }

    if (fCorrectionHandlerActivations != null) {
      JavaPlugin.logErrorMessage("correction handler activations not released"); // $NON-NLS-1$
    }
    fCorrectionHandlerActivations = new ArrayList();

    Collection definedCommandIds = commandService.getDefinedCommandIds();
    for (Iterator iter = definedCommandIds.iterator(); iter.hasNext(); ) {
      String id = (String) iter.next();
      if (id.startsWith(COMMAND_PREFIX)) {
        boolean isAssist = id.endsWith(ASSIST_SUFFIX);
        CorrectionCommandHandler handler = new CorrectionCommandHandler(editor, id, isAssist);
        IHandlerActivation activation =
            handlerService.activateHandler(
                id, handler, new LegacyHandlerSubmissionExpression(null, null, editor.getSite()));
        fCorrectionHandlerActivations.add(activation);
      }
    }
  }
  // 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());
  }
  @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 */
    }
  }
Ejemplo n.º 4
0
 /*
  * (non-Javadoc)
  *
  * @see org.eclipse.ui.plugin.AbstractUIPlugin#stop(org.osgi.framework.BundleContext)
  */
 @Override
 public void stop(final BundleContext context) throws Exception {
   Activator.plugin = null;
   // we remove the listener on the command service
   final ICommandService service =
       (ICommandService)
           PlatformUI.getWorkbench().getActiveWorkbenchWindow().getService(ICommandService.class);
   service.removeExecutionListener(this.commandServiceListener);
   super.stop(context);
 }
  /** {@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;
  }
Ejemplo n.º 6
0
 /*
  * (non-Javadoc)
  *
  * @see org.eclipse.ui.plugin.AbstractUIPlugin#start(org.osgi.framework.BundleContext)
  */
 @Override
 public void start(final BundleContext context) throws Exception {
   super.start(context);
   Activator.plugin = this;
   Activator.log = new LogHelper(this);
   // we add a listener on the command service
   this.commandServiceListener = new SaveEMFCompareListener();
   final ICommandService service =
       (ICommandService)
           PlatformUI.getWorkbench().getActiveWorkbenchWindow().getService(ICommandService.class);
   service.addExecutionListener(this.commandServiceListener);
 }
Ejemplo n.º 7
0
  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;
  }
Ejemplo n.º 8
0
 /** 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 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);
  }
Ejemplo n.º 10
0
  /*
   * (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 */
    }
  }
Ejemplo n.º 12
0
  public static void setCoolBarVisibility(boolean visible) {
    IWorkbenchWindow activeWorkbenchWindow = getActiveWorkbenchWindow();
    if (activeWorkbenchWindow instanceof WorkbenchWindow) {
      WorkbenchWindow workbenchWindow = (WorkbenchWindow) activeWorkbenchWindow;
      workbenchWindow.setCoolBarVisible(visible);
      workbenchWindow.setPerspectiveBarVisible(visible);

      // Try to force a refresh of the text on the action
      IWorkbenchPart activePart = getActivePart();
      if (activePart != null) {
        ICommandService cmdService =
            (ICommandService) activePart.getSite().getService(ICommandService.class);
        cmdService.refreshElements("org.eclipse.ui.ToggleCoolbarAction", null); // $NON-NLS-1$
      }
    }
  }
Ejemplo n.º 13
0
  private void defineAllCommands() {
    commandService = (ICommandService) PlatformUI.getWorkbench().getService(ICommandService.class);
    autogeneratedCategory = commandService.getCategory(CommandManager.AUTOGENERATED_CATEGORY_ID);

    defineCommand(newContactCommandId, Messages.getString("Label.NewContact"), newContactHandler);
    defineCommand(
        deleteContactCommandId, Messages.getString("Label.DeleteContact"), deleteContactHandler);

    defineCommand(
        deleteCertificateCommandId,
        Messages.getString("Label.DeleteCertificate"),
        deleteCertificateHandler);
    defineCommand(
        deleteKeyPairCommandId, Messages.getString("Label.DeleteKeyPair"), deleteKeyPairHandler);
    defineCommand(
        deleteSecretKeyCommandId,
        Messages.getString("Label.DeleteSecretKey"),
        deleteSecretKeyHandler);

    defineCommand(
        exportCertificateCommandId,
        org.jcryptool.crypto.keystore.ui.actions.ex.Messages.getString("Label.ExportPublicKey"),
        exportCertificateHandler);
    defineCommand(
        exportKeyPairCommandId,
        org.jcryptool.crypto.keystore.ui.actions.ex.Messages.getString("Label.ExportKeyPair"),
        exportKeyPairHandler);
    defineCommand(
        exportSecretKeyCommandId,
        org.jcryptool.crypto.keystore.ui.actions.ex.Messages.getString("Label.ExportSecretKey"),
        exportSecretKeyHandler);
  }
Ejemplo n.º 14
0
  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());
  }
Ejemplo n.º 15
0
  /* (non-Javadoc)
   * @see org.eclipse.core.commands.AbstractHandler#execute(org.eclipse.core.commands.ExecutionEvent)
   */
  @Override
  public Object execute(ExecutionEvent event) throws ExecutionException {
    String param = event.getParameter(ID_PARAMETER_MODE);
    if (param == null || param.equals(fCurrentValue)) return null;

    fCurrentValue = param;
    CDebugCorePlugin.getDefault()
        .getPluginPreferences()
        .setValue(ICDebugConstants.PREF_STEP_MODE, fCurrentValue);

    IWorkbenchWindow window = HandlerUtil.getActiveWorkbenchWindowChecked(event);
    ICommandService service = window.getService(ICommandService.class);
    service.refreshElements(event.getCommand().getId(), null);

    return null;
  }
Ejemplo n.º 16
0
 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();
   }
 }
Ejemplo n.º 17
0
  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;
      }
    }
  }
  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);
    }
  }
Ejemplo n.º 20
0
 private static void executeAction(
     final String action,
     final IHandlerService handlerService,
     final ICommandService commandService) {
   try {
     final ParameterizedCommand command = commandService.deserialize(action);
     handlerService.executeCommand(command, null);
   } catch (CommandException e) {
     VrapperLog.error("Command not handled: " + action, e);
   }
 }
  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);
    }
  }
  @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);
      }
    }
  }
Ejemplo n.º 24
0
 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();
     }
   }
 }
  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;
      }
    }
  }
 /*
  * (non-Javadoc)
  *
  * @see org.eclipse.jface.action.ContributionItem#dispose()
  */
 public void dispose() {
   if (elementRef != null) {
     commandService.unregisterElement(elementRef);
     elementRef = null;
   }
   if (commandListener != null) {
     command.getCommand().removeCommandListener(commandListener);
     commandListener = null;
   }
   command = null;
   commandService = null;
   disposeOldImages();
   super.dispose();
 }
Ejemplo n.º 28
0
  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());
  }
Ejemplo n.º 30
0
  /**
   * @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);
  }