Java Action类代码示例

import org.eclipse.che.ide.api.action.Action; //导入依赖的package包/类
public PaneMenuActionItemWidget(@NotNull Action action) {
  initWidget(UI_BINDER.createAndBindUi(this));
  this.action = action;
  Presentation presentation = action.getTemplatePresentation();
  title.setText(presentation.getText());

  addDomHandler(
      new ClickHandler() {
        @Override
        public void onClick(ClickEvent event) {
          if (delegate != null) {
            delegate.onItemClicked(PaneMenuActionItemWidget.this);
          }
        }
      },
      ClickEvent.getType());
}
 

import org.eclipse.che.ide.api.action.Action; //导入依赖的package包/类
private Node renderAction(String title, final Action action) {
  final Presentation presentation = presentationFactory.getPresentation(action);
  Element divElement = Elements.createDivElement(style.listElement());
  divElement.addEventListener(
      "click",
      new EventListener() {
        @Override
        public void handleEvent(Event evt) {
          ActionEvent event = new ActionEvent(presentation, actionManager);
          action.actionPerformed(event);
        }
      },
      true);
  divElement.getStyle().setCursor("pointer");
  divElement.getStyle().setColor(Style.getOutputLinkColor());
  Element label = Elements.createDivElement(style.actionLabel());
  label.setInnerText(title);
  divElement.appendChild(label);

  String hotKey =
      KeyMapUtil.getShortcutText(keyBindingAgent.getKeyBinding(actionManager.getId(action)));
  if (hotKey == null) {
    hotKey = " ";
  } else {
    hotKey = "<nobr>&nbsp;" + hotKey + "&nbsp;</nobr>";
  }
  SpanElement hotKeyElement = Elements.createSpanElement(style.hotKey());
  hotKeyElement.setInnerHTML(hotKey);
  divElement.appendChild(hotKeyElement);
  return divElement;
}
 

import org.eclipse.che.ide.api.action.Action; //导入依赖的package包/类
protected ActionGroup updateActions() {
  final ActionGroup mainActionGroup = (ActionGroup) actionManager.getAction(getGroupMenu());
  if (mainActionGroup == null) {
    return new DefaultActionGroup(actionManager);
  }

  final Action[] children = mainActionGroup.getChildren(null);
  for (final Action action : children) {
    final Presentation presentation = presentationFactory.getPresentation(action);
    // pass into action properties
    presentation.putClientProperty(CURRENT_FILE_PROP, editorTab.getFile());
    presentation.putClientProperty(CURRENT_TAB_PROP, editorTab);
    presentation.putClientProperty(CURRENT_PANE_PROP, editorPartStack);
  }
  return super.updateActions();
}
 

import org.eclipse.che.ide.api.action.Action; //导入依赖的package包/类
private void initializePaneMenu() {
  paneMenuTabItemHandler = new PaneMenuTabItemHandler();
  paneMenuActionItemHandler = new PaneMenuActionItemHandler();

  final EditorPaneMenuItem<Action> closePaneItemWidget =
      editorPaneMenuItemFactory.createMenuItem(closePaneAction);
  closePaneItemWidget.setDelegate(paneMenuActionItemHandler);
  editorPaneMenu.addItem(closePaneItemWidget);

  final EditorPaneMenuItem<Action> closeAllTabsItemWidget =
      editorPaneMenuItemFactory.createMenuItem(closeAllTabsPaneAction);
  closeAllTabsItemWidget.setDelegate(paneMenuActionItemHandler);
  editorPaneMenu.addItem(closeAllTabsItemWidget, true);

  final Action splitHorizontallyAction = actionManager.getAction(SPLIT_HORIZONTALLY);
  final EditorPaneMenuItem<Action> splitHorizontallyItemWidget =
      editorPaneMenuItemFactory.createMenuItem(splitHorizontallyAction);
  splitHorizontallyItemWidget.setDelegate(paneMenuActionItemHandler);
  editorPaneMenu.addItem(splitHorizontallyItemWidget);

  final Action splitVerticallyAction = actionManager.getAction(SPLIT_VERTICALLY);
  final EditorPaneMenuItem<Action> splitVerticallyItemWidget =
      editorPaneMenuItemFactory.createMenuItem(splitVerticallyAction);
  splitVerticallyItemWidget.setDelegate(paneMenuActionItemHandler);
  editorPaneMenu.addItem(splitVerticallyItemWidget);
}
 

import org.eclipse.che.ide.api.action.Action; //导入依赖的package包/类
@Override
public void onItemClicked(@NotNull EditorPaneMenuItem<Action> item) {
  editorPaneMenu.hide();

  final Action action = item.getData();
  final Presentation presentation = presentationFactory.getPresentation(action);
  presentation.putClientProperty(CURRENT_PANE_PROP, EditorPartStackPresenter.this);

  final PartPresenter activePart = getActivePart();
  final TabItem tab = getTabByPart(activePart);

  if (tab != null) {
    final VirtualFile virtualFile = ((EditorTab) tab).getFile();
    // pass into action file property and editor tab
    presentation.putClientProperty(CURRENT_TAB_PROP, tab);
    presentation.putClientProperty(CURRENT_FILE_PROP, virtualFile);
  }
  action.actionPerformed(new ActionEvent(presentation, actionManager, null));
}
 

import org.eclipse.che.ide.api.action.Action; //导入依赖的package包/类
@Override
public void unregisterAction(String actionId) {
  if (!myId2Action.containsKey(actionId)) {
    Log.debug(getClass(), "action with ID " + actionId + " wasn't registered");
    return;
  }
  Action oldValue = (Action) myId2Action.remove(actionId);
  myAction2Id.remove(oldValue);
  myId2Index.remove(actionId);

  for (Entry<String, Set<String>> entry : myPlugin2Id.entrySet()) {
    final Set<String> pluginActions = entry.getValue();
    if (pluginActions != null) {
      pluginActions.remove(actionId);
    }
  }
}
 

import org.eclipse.che.ide.api.action.Action; //导入依赖的package包/类
private List<String> getExcludedActionIds(ActionManager actionManager) {
  List<String> ids = new ArrayList<>();

  DefaultActionGroup editGroup =
      (DefaultActionGroup) actionManager.getAction(IdeActions.GROUP_RECENT_FILES);
  Action[] children = editGroup.getChildActionsOrStubs();
  for (Action child : children) {
    if (child instanceof Separator) {
      continue;
    }

    ids.add(actionManager.getId(child));
  }

  return unmodifiableList(ids);
}
 

import org.eclipse.che.ide.api.action.Action; //导入依赖的package包/类
/**
 * Finds and runs an action cancelling original key event
 *
 * @param actionIds list containing action ids
 * @param keyEvent original key event
 */
private void runActions(List<String> actionIds, Event keyEvent) {
  for (String actionId : actionIds) {
    Action action = actionManager.getAction(actionId);
    if (action == null) {
      continue;
    }
    ActionEvent e = new ActionEvent(presentationFactory.getPresentation(action), actionManager);
    action.update(e);

    if (e.getPresentation().isEnabled() && e.getPresentation().isVisible()) {
      /** Stop handling the key event */
      keyEvent.preventDefault();
      keyEvent.stopPropagation();

      /** Perform the action */
      action.actionPerformed(e);
    }
  }
}
 

import org.eclipse.che.ide.api.action.Action; //导入依赖的package包/类
/**
 * Removes action for executing the given command and removes the appropriate action group in case
 * it's empty.
 */
private void removeAction(CommandImpl command) {
  Action commandAction = commandActions.remove(command.getName());

  if (commandAction != null) {
    removeAction(commandAction);

    // remove action from it's action group
    String goalId = command.getGoal();
    if (isNullOrEmpty(goalId)) {
      goalId = goalRegistry.getDefaultGoal().getId();
    }

    // remove action group if it's empty
    DefaultActionGroup goalPopUpGroup = goalPopUpGroups.remove(goalId);

    if (goalPopUpGroup != null) {
      goalPopUpGroup.remove(commandAction);

      if (goalPopUpGroup.getChildrenCount() == 0) {
        removeAction(goalPopUpGroup);
      }
    }
  }
}
 

import org.eclipse.che.ide.api.action.Action; //导入依赖的package包/类
public MenuItemActionWidget(Action action) {
  initWidget(UI_BINDER.createAndBindUi(this));
  this.action = action;

  final Element actionIcon = action.getTemplatePresentation().getImageElement();
  if (actionIcon != null) {
    iconPanel.add(new ElementWidget(actionIcon));
  }

  title.setText(action.getTemplatePresentation().getText());

  addDomHandler(
      new ClickHandler() {
        @Override
        public void onClick(ClickEvent event) {
          if (delegate != null) {
            delegate.onItemSelected(MenuItemActionWidget.this);
          }
        }
      },
      ClickEvent.getType());
}
 

import org.eclipse.che.ide.api.action.Action; //导入依赖的package包/类
private boolean isRowEnabled(Element tr) {
  if (tr == null) {
    return false;
  }

  String index = tr.getAttribute("item-index");
  if (index == null || "".equals(index)) {
    return false;
  }

  String enabled = tr.getAttribute("item-enabled");
  if (enabled == null || "".equals(enabled) || "false".equals(enabled)) {
    return false;
  }

  int itemIndex = Integer.parseInt(index);
  Action menuItem = list.get(itemIndex);
  return presentationFactory.getPresentation(menuItem).isEnabled();
}
 

import org.eclipse.che.ide.api.action.Action; //导入依赖的package包/类
/**
 * Handle Mouse Click
 *
 * @param tr
 */
protected void onRowClicked(Element tr) {
  if (!isRowEnabled(tr) || tr == subPopupAnchor) {
    return;
  }

  int itemIndex = Integer.parseInt(tr.getAttribute("item-index"));
  Action menuItem = list.get(itemIndex);
  if (menuItem instanceof ActionGroup
      && (!((ActionGroup) menuItem).canBePerformed()
          && Utils.hasVisibleChildren(
              (ActionGroup) menuItem, presentationFactory, actionManager))) {
    openSubPopup(tr);
  } else {
    if (actionSelectedHandler != null) {
      actionSelectedHandler.onActionSelected(menuItem);
    }
    ActionEvent e = new ActionEvent(presentationFactory.getPresentation(menuItem), actionManager);
    menuItem.actionPerformed(e);
  }
}
 

import org.eclipse.che.ide.api.action.Action; //导入依赖的package包/类
@Override
protected ActionGroup updateActions() {
  ActionGroup actionGroup = super.updateActions();
  for (Action action : actionGroup.getChildren(null)) {
    Presentation presentation = action.getTemplatePresentation();
    presentation.putClientProperty(BREAKPOINT, breakpoint);
  }

  return actionGroup;
}
 

import org.eclipse.che.ide.api.action.Action; //导入依赖的package包/类
private void render(String title, Map<String, Action> actions) {
  this.title.setInnerText(title);
  container.removeAllChildren();
  Element listElement = Elements.createElement("ul", new String[] {style.list()});

  for (Map.Entry<String, Action> pair : actions.entrySet()) {
    LIElement liElement = Elements.createLiElement();
    liElement.appendChild(renderAction(pair.getKey(), pair.getValue()));
    listElement.appendChild(liElement);
  }

  container.appendChild((com.google.gwt.dom.client.Node) listElement);
}
 

import org.eclipse.che.ide.api.action.Action; //导入依赖的package包/类
protected ActionGroup updateActions() {
  DefaultActionGroup defaultGroup = new DefaultActionGroup(actionManager);

  final ActionGroup actionGroup =
      (ActionGroup) actionManager.getAction(IdeActions.GROUP_FILE_NEW);

  for (Action action : actionGroup.getChildren(null)) {
    defaultGroup.add(action);
  }

  return defaultGroup;
}