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;
}
 

import org.eclipse.che.ide.api.action.Action; //导入依赖的package包/类
@Override
public void performAction(String actionId, Map<String, String> parameters) {
  final Action action;
  if (actionId != null && (action = getAction(actionId)) != null) {
    final Presentation presentation = presentationFactory.getPresentation(action);
    final ActionEvent actionEvent = new ActionEvent(presentation, this, parameters);

    action.update(actionEvent);

    if (presentation.isEnabled() && presentation.isVisible()) {
      action.actionPerformed(actionEvent);
    }
  }
}
 

import org.eclipse.che.ide.api.action.Action; //导入依赖的package包/类
/**
 * Returns promise returned by PromisableAction or already resolved promise for
 * non-PromisableAction.
 */
private Promise<Void> promiseAction(final Action action, final ActionEvent event) {
  if (action instanceof PromisableAction) {
    return ((PromisableAction) action).promise(event);
  } else {
    action.actionPerformed(event);
    return Promises.resolve(null);
  }
}
 

import org.eclipse.che.ide.api.action.Action; //导入依赖的package包/类
public Action getParentGroup(
    final String groupId, final String actionName, final String pluginId) {
  if (groupId == null || groupId.length() == 0) {
    reportActionError(pluginId, actionName + ": attribute \"group-id\" should be defined");
    return null;
  }
  Action parentGroup = getActionImpl(groupId, true);
  if (parentGroup == null) {
    reportActionError(
        pluginId,
        actionName
            + ": group with id \""
            + groupId
            + "\" isn't registered; action will be added to the \"Other\" group");
    parentGroup = getActionImpl(IdeActions.GROUP_OTHER_MENU, true);
  }
  if (!(parentGroup instanceof DefaultActionGroup)) {
    reportActionError(
        pluginId,
        actionName
            + ": group with id \""
            + groupId
            + "\" should be instance of "
            + DefaultActionGroup.class.getName()
            + " but was "
            + parentGroup.getClass());
    return null;
  }
  return parentGroup;
}
 

import org.eclipse.che.ide.api.action.Action; //导入依赖的package包/类
@Override
public void registerAction(String actionId, Action action, String pluginId) {
  if (myId2Action.containsKey(actionId)) {
    reportActionError(
        pluginId,
        "action with the ID \""
            + actionId
            + "\" was already registered. Action being registered is "
            + action.toString()
            + "; Registered action is "
            + myId2Action.get(actionId)
            + pluginId);
    return;
  }
  if (myAction2Id.containsKey(action)) {
    reportActionError(
        pluginId,
        "action was already registered for another ID. ID is "
            + myAction2Id.get(action)
            + pluginId);
    return;
  }
  myId2Action.put(actionId, action);
  myId2Index.put(actionId, myRegisteredActionsCount++);
  myAction2Id.put(action, actionId);
  if (pluginId != null && !(action instanceof ActionGroup)) {
    Set<String> pluginActionIds = myPlugin2Id.get(pluginId);
    if (pluginActionIds == null) {
      pluginActionIds = new HashSet<>();
      myPlugin2Id.put(pluginId, pluginActionIds);
    }
    pluginActionIds.add(actionId);
  }
}
 

import org.eclipse.che.ide.api.action.Action; //导入依赖的package包/类
public void show() {
  view.show();
  Action action = actionManager.getAction(IdeActions.GROUP_MAIN_MENU);
  collectActions(actionsMap, (ActionGroup) action, action.getTemplatePresentation().getText());
  view.focusOnInput();
  if (view.getName() != null) {
    nameChanged(view.getName(), view.getCheckBoxState());
  }
}