| /* |
| * Copyright (C) 2010 The Android Open Source Project |
| * |
| * Licensed under the Eclipse Public License, Version 1.0 (the "License"); |
| * you may not use this file except in compliance with the License. |
| * You may obtain a copy of the License at |
| * |
| * http://www.eclipse.org/org/documents/epl-v10.php |
| * |
| * Unless required by applicable law or agreed to in writing, software |
| * distributed under the License is distributed on an "AS IS" BASIS, |
| * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. |
| * See the License for the specific language governing permissions and |
| * limitations under the License. |
| */ |
| |
| package com.android.ide.eclipse.adt.internal.editors.layout.gle2; |
| |
| import static com.android.SdkConstants.ANDROID_URI; |
| import static com.android.SdkConstants.ATTR_ID; |
| import static com.android.SdkConstants.EXPANDABLE_LIST_VIEW; |
| import static com.android.SdkConstants.FQCN_GESTURE_OVERLAY_VIEW; |
| import static com.android.SdkConstants.FQCN_IMAGE_VIEW; |
| import static com.android.SdkConstants.FQCN_LINEAR_LAYOUT; |
| import static com.android.SdkConstants.FQCN_TEXT_VIEW; |
| import static com.android.SdkConstants.GRID_VIEW; |
| import static com.android.SdkConstants.LIST_VIEW; |
| import static com.android.SdkConstants.SPINNER; |
| import static com.android.SdkConstants.VIEW_FRAGMENT; |
| |
| import com.android.SdkConstants; |
| import com.android.ide.common.api.INode; |
| import com.android.ide.common.api.IViewRule; |
| import com.android.ide.common.api.RuleAction; |
| import com.android.ide.common.api.RuleAction.Choices; |
| import com.android.ide.common.api.RuleAction.NestedAction; |
| import com.android.ide.common.api.RuleAction.Toggle; |
| import com.android.ide.common.layout.BaseViewRule; |
| import com.android.ide.eclipse.adt.internal.editors.layout.LayoutEditorDelegate; |
| import com.android.ide.eclipse.adt.internal.editors.layout.gre.NodeFactory; |
| import com.android.ide.eclipse.adt.internal.editors.layout.gre.NodeProxy; |
| import com.android.ide.eclipse.adt.internal.editors.layout.refactoring.ChangeLayoutAction; |
| import com.android.ide.eclipse.adt.internal.editors.layout.refactoring.ChangeViewAction; |
| import com.android.ide.eclipse.adt.internal.editors.layout.refactoring.ExtractIncludeAction; |
| import com.android.ide.eclipse.adt.internal.editors.layout.refactoring.ExtractStyleAction; |
| import com.android.ide.eclipse.adt.internal.editors.layout.refactoring.UnwrapAction; |
| import com.android.ide.eclipse.adt.internal.editors.layout.refactoring.UseCompoundDrawableAction; |
| import com.android.ide.eclipse.adt.internal.editors.layout.refactoring.WrapInAction; |
| import com.android.ide.eclipse.adt.internal.editors.layout.uimodel.UiViewElementNode; |
| |
| import org.eclipse.jface.action.Action; |
| import org.eclipse.jface.action.ActionContributionItem; |
| import org.eclipse.jface.action.ContributionItem; |
| import org.eclipse.jface.action.IAction; |
| import org.eclipse.jface.action.IContributionItem; |
| import org.eclipse.jface.action.IMenuListener; |
| import org.eclipse.jface.action.IMenuManager; |
| import org.eclipse.jface.action.MenuManager; |
| import org.eclipse.jface.action.Separator; |
| import org.eclipse.swt.SWT; |
| import org.eclipse.swt.widgets.Event; |
| import org.eclipse.swt.widgets.Menu; |
| |
| import java.util.ArrayList; |
| import java.util.Collections; |
| import java.util.HashMap; |
| import java.util.HashSet; |
| import java.util.List; |
| import java.util.Map; |
| import java.util.Set; |
| |
| /** |
| * Helper class that is responsible for adding and managing the dynamic menu items |
| * contributed by the {@link IViewRule} instances, based on the current selection |
| * on the {@link LayoutCanvas}. |
| * <p/> |
| * This class is tied to a specific {@link LayoutCanvas} instance and a root {@link MenuManager}. |
| * <p/> |
| * Two instances of this are used: one created by {@link LayoutCanvas} and the other one |
| * created by {@link OutlinePage}. Different root {@link MenuManager}s are populated, however |
| * they are both linked to the current selection state of the {@link LayoutCanvas}. |
| */ |
| class DynamicContextMenu { |
| public static String DEFAULT_ACTION_SHORTCUT = "F2"; //$NON-NLS-1$ |
| public static int DEFAULT_ACTION_KEY = SWT.F2; |
| |
| /** The XML layout editor that contains the canvas that uses this menu. */ |
| private final LayoutEditorDelegate mEditorDelegate; |
| |
| /** The layout canvas that displays this context menu. */ |
| private final LayoutCanvas mCanvas; |
| |
| /** The root menu manager of the context menu. */ |
| private final MenuManager mMenuManager; |
| |
| /** |
| * Creates a new helper responsible for adding and managing the dynamic menu items |
| * contributed by the {@link IViewRule} instances, based on the current selection |
| * on the {@link LayoutCanvas}. |
| * @param editorDelegate the editor owning the menu |
| * @param canvas The {@link LayoutCanvas} providing the selection, the node factory and |
| * the rules engine. |
| * @param rootMenu The root of the context menu displayed. In practice this may be the |
| * context menu manager of the {@link LayoutCanvas} or the one from {@link OutlinePage}. |
| */ |
| public DynamicContextMenu( |
| LayoutEditorDelegate editorDelegate, |
| LayoutCanvas canvas, |
| MenuManager rootMenu) { |
| mEditorDelegate = editorDelegate; |
| mCanvas = canvas; |
| mMenuManager = rootMenu; |
| |
| setupDynamicMenuActions(); |
| } |
| |
| /** |
| * Setups the menu manager to receive dynamic menu contributions from the {@link IViewRule}s |
| * when it's about to be shown. |
| */ |
| private void setupDynamicMenuActions() { |
| // Remember how many static actions we have. Then each time the menu is |
| // shown, find dynamic contributions based on the current selection and insert |
| // them at the beginning of the menu. |
| final int numStaticActions = mMenuManager.getSize(); |
| mMenuManager.addMenuListener(new IMenuListener() { |
| @Override |
| public void menuAboutToShow(IMenuManager manager) { |
| |
| // Remove any previous dynamic contributions to keep only the |
| // default static items. |
| int n = mMenuManager.getSize() - numStaticActions; |
| if (n > 0) { |
| IContributionItem[] items = mMenuManager.getItems(); |
| for (int i = 0; i < n; i++) { |
| mMenuManager.remove(items[i]); |
| } |
| } |
| |
| // Now add all the dynamic menu actions depending on the current selection. |
| populateDynamicContextMenu(); |
| } |
| }); |
| |
| } |
| |
| /** |
| * This method is invoked by <code>menuAboutToShow</code> on {@link #mMenuManager}. |
| * All previous dynamic menu actions have been removed and this method can now insert |
| * any new actions that depend on the current selection. |
| */ |
| private void populateDynamicContextMenu() { |
| // Create the actual menu contributions |
| String endId = mMenuManager.getItems()[0].getId(); |
| |
| Separator sep = new Separator(); |
| sep.setId("-dyn-gle-sep"); //$NON-NLS-1$ |
| mMenuManager.insertBefore(endId, sep); |
| endId = sep.getId(); |
| |
| List<SelectionItem> selections = mCanvas.getSelectionManager().getSelections(); |
| if (selections.size() == 0) { |
| return; |
| } |
| List<INode> nodes = new ArrayList<INode>(selections.size()); |
| for (SelectionItem item : selections) { |
| nodes.add(item.getNode()); |
| } |
| |
| List<IContributionItem> menuItems = getMenuItems(nodes); |
| for (IContributionItem menuItem : menuItems) { |
| mMenuManager.insertBefore(endId, menuItem); |
| } |
| |
| insertTagSpecificMenus(endId); |
| insertVisualRefactorings(endId); |
| insertParentItems(endId); |
| } |
| |
| /** |
| * Returns the list of node-specific actions applicable to the given |
| * collection of nodes |
| * |
| * @param nodes the collection of nodes to look up actions for |
| * @return a list of contribution items applicable for all the nodes |
| */ |
| private List<IContributionItem> getMenuItems(List<INode> nodes) { |
| Map<INode, List<RuleAction>> allActions = new HashMap<INode, List<RuleAction>>(); |
| for (INode node : nodes) { |
| List<RuleAction> actionList = getMenuActions((NodeProxy) node); |
| allActions.put(node, actionList); |
| } |
| |
| Set<String> availableIds = computeApplicableActionIds(allActions); |
| |
| // +10: Make room for separators too |
| List<IContributionItem> items = new ArrayList<IContributionItem>(availableIds.size() + 10); |
| |
| // We'll use the actions returned by the first node. Even when there |
| // are multiple items selected, we'll use the first action, but pass |
| // the set of all selected nodes to that first action. Actions are required |
| // to work this way to facilitate multi selection and actions which apply |
| // to multiple nodes. |
| NodeProxy first = (NodeProxy) nodes.get(0); |
| List<RuleAction> firstSelectedActions = allActions.get(first); |
| String defaultId = getDefaultActionId(first); |
| for (RuleAction action : firstSelectedActions) { |
| if (!availableIds.contains(action.getId()) |
| && !(action instanceof RuleAction.Separator)) { |
| // This action isn't supported by all selected items. |
| continue; |
| } |
| |
| items.add(createContributionItem(action, nodes, defaultId)); |
| } |
| |
| return items; |
| } |
| |
| private void insertParentItems(String endId) { |
| List<SelectionItem> selection = mCanvas.getSelectionManager().getSelections(); |
| if (selection.size() == 1) { |
| mMenuManager.insertBefore(endId, new Separator()); |
| INode parent = selection.get(0).getNode().getParent(); |
| while (parent != null) { |
| String id = parent.getStringAttr(ANDROID_URI, ATTR_ID); |
| String label; |
| if (id != null && id.length() > 0) { |
| label = BaseViewRule.stripIdPrefix(id); |
| } else { |
| // Use the view name, such as "Button", as the label |
| label = parent.getFqcn(); |
| // Strip off package |
| label = label.substring(label.lastIndexOf('.') + 1); |
| } |
| mMenuManager.insertBefore(endId, new NestedParentMenu(label, parent)); |
| parent = parent.getParent(); |
| } |
| mMenuManager.insertBefore(endId, new Separator()); |
| } |
| } |
| |
| private void insertVisualRefactorings(String endId) { |
| // Extract As <include> refactoring, Wrap In Refactoring, etc. |
| List<SelectionItem> selection = mCanvas.getSelectionManager().getSelections(); |
| if (selection.size() == 0) { |
| return; |
| } |
| // Only include the menu item if you are not right clicking on a root, |
| // or on an included view, or on a non-contiguous selection |
| mMenuManager.insertBefore(endId, new Separator()); |
| if (selection.size() == 1 && selection.get(0).getViewInfo() != null |
| && selection.get(0).getViewInfo().getName().equals(FQCN_LINEAR_LAYOUT)) { |
| CanvasViewInfo info = selection.get(0).getViewInfo(); |
| List<CanvasViewInfo> children = info.getChildren(); |
| if (children.size() == 2) { |
| String first = children.get(0).getName(); |
| String second = children.get(1).getName(); |
| if ((first.equals(FQCN_IMAGE_VIEW) && second.equals(FQCN_TEXT_VIEW)) |
| || (first.equals(FQCN_TEXT_VIEW) && second.equals(FQCN_IMAGE_VIEW))) { |
| mMenuManager.insertBefore(endId, UseCompoundDrawableAction.create( |
| mEditorDelegate)); |
| } |
| } |
| } |
| mMenuManager.insertBefore(endId, ExtractIncludeAction.create(mEditorDelegate)); |
| mMenuManager.insertBefore(endId, ExtractStyleAction.create(mEditorDelegate)); |
| mMenuManager.insertBefore(endId, WrapInAction.create(mEditorDelegate)); |
| if (selection.size() == 1 && !(selection.get(0).isRoot())) { |
| mMenuManager.insertBefore(endId, UnwrapAction.create(mEditorDelegate)); |
| } |
| if (selection.size() == 1 && (selection.get(0).isLayout() || |
| selection.get(0).getViewInfo().getName().equals(FQCN_GESTURE_OVERLAY_VIEW))) { |
| mMenuManager.insertBefore(endId, ChangeLayoutAction.create(mEditorDelegate)); |
| } else { |
| mMenuManager.insertBefore(endId, ChangeViewAction.create(mEditorDelegate)); |
| } |
| mMenuManager.insertBefore(endId, new Separator()); |
| } |
| |
| /** "Preview List Content" pull-right menu for lists, "Preview Fragment" for fragments, etc. */ |
| private void insertTagSpecificMenus(String endId) { |
| |
| List<SelectionItem> selection = mCanvas.getSelectionManager().getSelections(); |
| if (selection.size() == 0) { |
| return; |
| } |
| for (SelectionItem item : selection) { |
| UiViewElementNode node = item.getViewInfo().getUiViewNode(); |
| String name = node.getDescriptor().getXmlLocalName(); |
| boolean isGrid = name.equals(GRID_VIEW); |
| boolean isSpinner = name.equals(SPINNER); |
| if (name.equals(LIST_VIEW) || name.equals(EXPANDABLE_LIST_VIEW) |
| || isGrid || isSpinner) { |
| mMenuManager.insertBefore(endId, new Separator()); |
| mMenuManager.insertBefore(endId, new ListViewTypeMenu(mCanvas, isGrid, isSpinner)); |
| return; |
| } else if (name.equals(VIEW_FRAGMENT) && selection.size() == 1) { |
| mMenuManager.insertBefore(endId, new Separator()); |
| mMenuManager.insertBefore(endId, new FragmentMenu(mCanvas)); |
| return; |
| } |
| } |
| } |
| |
| /** |
| * Given a map from selection items to list of applicable actions (produced |
| * by {@link #computeApplicableActions()}) this method computes the set of |
| * common actions and returns the action ids of these actions. |
| * |
| * @param actions a map from selection item to list of actions applicable to |
| * that selection item |
| * @return set of action ids for the actions that are present in the action |
| * lists for all selected items |
| */ |
| private Set<String> computeApplicableActionIds(Map<INode, List<RuleAction>> actions) { |
| if (actions.size() > 1) { |
| // More than one view is selected, so we have to filter down the available |
| // actions such that only those actions that are defined for all the views |
| // are shown |
| Map<String, Integer> idCounts = new HashMap<String, Integer>(); |
| for (Map.Entry<INode, List<RuleAction>> entry : actions.entrySet()) { |
| List<RuleAction> actionList = entry.getValue(); |
| for (RuleAction action : actionList) { |
| if (!action.supportsMultipleNodes()) { |
| continue; |
| } |
| String id = action.getId(); |
| if (id != null) { |
| assert id != null : action; |
| Integer count = idCounts.get(id); |
| if (count == null) { |
| idCounts.put(id, Integer.valueOf(1)); |
| } else { |
| idCounts.put(id, count + 1); |
| } |
| } |
| } |
| } |
| Integer selectionCount = Integer.valueOf(actions.size()); |
| Set<String> validIds = new HashSet<String>(idCounts.size()); |
| for (Map.Entry<String, Integer> entry : idCounts.entrySet()) { |
| Integer count = entry.getValue(); |
| if (selectionCount.equals(count)) { |
| String id = entry.getKey(); |
| validIds.add(id); |
| } |
| } |
| return validIds; |
| } else { |
| List<RuleAction> actionList = actions.values().iterator().next(); |
| Set<String> validIds = new HashSet<String>(actionList.size()); |
| for (RuleAction action : actionList) { |
| String id = action.getId(); |
| validIds.add(id); |
| } |
| return validIds; |
| } |
| } |
| |
| /** |
| * Returns the menu actions computed by the rule associated with this node. |
| * |
| * @param node the canvas node we need menu actions for |
| * @return a list of {@link RuleAction} objects applicable to the node |
| */ |
| private List<RuleAction> getMenuActions(NodeProxy node) { |
| List<RuleAction> actions = mCanvas.getRulesEngine().callGetContextMenu(node); |
| if (actions == null || actions.size() == 0) { |
| return null; |
| } |
| |
| return actions; |
| } |
| |
| /** |
| * Returns the default action id, or null |
| * |
| * @param node the node to look up the default action for |
| * @return the action id, or null |
| */ |
| private String getDefaultActionId(NodeProxy node) { |
| return mCanvas.getRulesEngine().callGetDefaultActionId(node); |
| } |
| |
| /** |
| * Creates a {@link ContributionItem} for the given {@link RuleAction}. |
| * |
| * @param action the action to create a {@link ContributionItem} for |
| * @param nodes the set of nodes the action should be applied to |
| * @param defaultId if not non null, the id of an action which should be considered default |
| * @return a new {@link ContributionItem} which implements the given action |
| * on the given nodes |
| */ |
| private ContributionItem createContributionItem(final RuleAction action, |
| final List<INode> nodes, final String defaultId) { |
| if (action instanceof RuleAction.Separator) { |
| return new Separator(); |
| } else if (action instanceof NestedAction) { |
| NestedAction parentAction = (NestedAction) action; |
| return new ActionContributionItem(new NestedActionMenu(parentAction, nodes)); |
| } else if (action instanceof Choices) { |
| Choices parentAction = (Choices) action; |
| return new ActionContributionItem(new NestedChoiceMenu(parentAction, nodes)); |
| } else if (action instanceof Toggle) { |
| return new ActionContributionItem(createToggleAction(action, nodes)); |
| } else { |
| return new ActionContributionItem(createPlainAction(action, nodes, defaultId)); |
| } |
| } |
| |
| private Action createToggleAction(final RuleAction action, final List<INode> nodes) { |
| Toggle toggleAction = (Toggle) action; |
| final boolean isChecked = toggleAction.isChecked(); |
| Action a = new Action(action.getTitle(), IAction.AS_CHECK_BOX) { |
| @Override |
| public void run() { |
| String label = createActionLabel(action, nodes); |
| mEditorDelegate.getEditor().wrapUndoEditXmlModel(label, new Runnable() { |
| @Override |
| public void run() { |
| action.getCallback().action(action, nodes, |
| null/* no valueId for a toggle */, !isChecked); |
| applyPendingChanges(); |
| } |
| }); |
| } |
| }; |
| a.setId(action.getId()); |
| a.setChecked(isChecked); |
| return a; |
| } |
| |
| private IAction createPlainAction(final RuleAction action, final List<INode> nodes, |
| final String defaultId) { |
| IAction a = new Action(action.getTitle(), IAction.AS_PUSH_BUTTON) { |
| @Override |
| public void run() { |
| String label = createActionLabel(action, nodes); |
| mEditorDelegate.getEditor().wrapUndoEditXmlModel(label, new Runnable() { |
| @Override |
| public void run() { |
| action.getCallback().action(action, nodes, null, |
| Boolean.TRUE); |
| applyPendingChanges(); |
| } |
| }); |
| } |
| }; |
| |
| String id = action.getId(); |
| if (defaultId != null && id.equals(defaultId)) { |
| a.setAccelerator(DEFAULT_ACTION_KEY); |
| String text = a.getText(); |
| text = text + '\t' + DEFAULT_ACTION_SHORTCUT; |
| a.setText(text); |
| |
| } else if (ATTR_ID.equals(id)) { |
| // Keep in sync with {@link LayoutCanvas#handleKeyPressed} |
| if (SdkConstants.CURRENT_PLATFORM == SdkConstants.PLATFORM_DARWIN) { |
| a.setAccelerator('R' | SWT.MOD1 | SWT.MOD3); |
| // Option+Command |
| a.setText(a.getText().trim() + "\t\u2325\u2318R"); //$NON-NLS-1$ |
| } else if (SdkConstants.CURRENT_PLATFORM == SdkConstants.PLATFORM_LINUX) { |
| a.setAccelerator('R' | SWT.MOD2 | SWT.MOD3); |
| a.setText(a.getText() + "\tShift+Alt+R"); //$NON-NLS-1$ |
| } else { |
| a.setAccelerator('R' | SWT.MOD2 | SWT.MOD3); |
| a.setText(a.getText() + "\tAlt+Shift+R"); //$NON-NLS-1$ |
| } |
| } |
| a.setId(id); |
| return a; |
| } |
| |
| private static String createActionLabel(final RuleAction action, final List<INode> nodes) { |
| String label = action.getTitle(); |
| if (nodes.size() > 1) { |
| label += String.format(" (%d elements)", nodes.size()); |
| } |
| return label; |
| } |
| |
| /** |
| * The {@link NestedParentMenu} provides submenu content which adds actions |
| * available on one of the selected node's parent nodes. This will be |
| * similar to the menu content for the selected node, except the parent |
| * menus will not be embedded within the nested menu. |
| */ |
| private class NestedParentMenu extends SubmenuAction { |
| INode mParent; |
| |
| NestedParentMenu(String title, INode parent) { |
| super(title); |
| mParent = parent; |
| } |
| |
| @Override |
| protected void addMenuItems(Menu menu) { |
| List<SelectionItem> selection = mCanvas.getSelectionManager().getSelections(); |
| if (selection.size() == 0) { |
| return; |
| } |
| |
| List<IContributionItem> menuItems = getMenuItems(Collections.singletonList(mParent)); |
| for (IContributionItem menuItem : menuItems) { |
| menuItem.fill(menu, -1); |
| } |
| } |
| } |
| |
| /** |
| * The {@link NestedActionMenu} creates a lazily populated pull-right menu |
| * where the children are {@link RuleAction}'s themselves. |
| */ |
| private class NestedActionMenu extends SubmenuAction { |
| private final NestedAction mParentAction; |
| private final List<INode> mNodes; |
| |
| NestedActionMenu(NestedAction parentAction, List<INode> nodes) { |
| super(parentAction.getTitle()); |
| mParentAction = parentAction; |
| mNodes = nodes; |
| |
| assert mNodes.size() > 0; |
| } |
| |
| @Override |
| protected void addMenuItems(Menu menu) { |
| Map<INode, List<RuleAction>> allActions = new HashMap<INode, List<RuleAction>>(); |
| for (INode node : mNodes) { |
| List<RuleAction> actionList = mParentAction.getNestedActions(node); |
| allActions.put(node, actionList); |
| } |
| |
| Set<String> availableIds = computeApplicableActionIds(allActions); |
| |
| NodeProxy first = (NodeProxy) mNodes.get(0); |
| String defaultId = getDefaultActionId(first); |
| List<RuleAction> firstSelectedActions = allActions.get(first); |
| |
| int count = 0; |
| for (RuleAction firstAction : firstSelectedActions) { |
| if (!availableIds.contains(firstAction.getId()) |
| && !(firstAction instanceof RuleAction.Separator)) { |
| // This action isn't supported by all selected items. |
| continue; |
| } |
| |
| createContributionItem(firstAction, mNodes, defaultId).fill(menu, -1); |
| count++; |
| } |
| |
| if (count == 0) { |
| addDisabledMessageItem("<Empty>"); |
| } |
| } |
| } |
| |
| private void applyPendingChanges() { |
| LayoutCanvas canvas = mEditorDelegate.getGraphicalEditor().getCanvasControl(); |
| CanvasViewInfo root = canvas.getViewHierarchy().getRoot(); |
| if (root != null) { |
| UiViewElementNode uiViewNode = root.getUiViewNode(); |
| NodeFactory nodeFactory = canvas.getNodeFactory(); |
| NodeProxy rootNode = nodeFactory.create(uiViewNode); |
| if (rootNode != null) { |
| rootNode.applyPendingChanges(); |
| } |
| } |
| } |
| |
| /** |
| * The {@link NestedChoiceMenu} creates a lazily populated pull-right menu |
| * where the items in the menu are strings |
| */ |
| private class NestedChoiceMenu extends SubmenuAction { |
| private final Choices mParentAction; |
| private final List<INode> mNodes; |
| |
| NestedChoiceMenu(Choices parentAction, List<INode> nodes) { |
| super(parentAction.getTitle()); |
| mParentAction = parentAction; |
| mNodes = nodes; |
| } |
| |
| @Override |
| protected void addMenuItems(Menu menu) { |
| List<String> titles = mParentAction.getTitles(); |
| List<String> ids = mParentAction.getIds(); |
| String current = mParentAction.getCurrent(); |
| assert titles.size() == ids.size(); |
| String[] currentValues = current != null |
| && current.indexOf(RuleAction.CHOICE_SEP) != -1 ? |
| current.split(RuleAction.CHOICE_SEP_PATTERN) : null; |
| for (int i = 0, n = Math.min(titles.size(), ids.size()); i < n; i++) { |
| final String id = ids.get(i); |
| if (id == null || id.equals(RuleAction.SEPARATOR)) { |
| new Separator().fill(menu, -1); |
| continue; |
| } |
| |
| // Find out whether this item is selected |
| boolean select = false; |
| if (current != null) { |
| // The current choice has a separator, so it's a flag with |
| // multiple values selected. Compare keys with the split |
| // values. |
| if (currentValues != null) { |
| if (current.indexOf(id) >= 0) { |
| for (String value : currentValues) { |
| if (id.equals(value)) { |
| select = true; |
| break; |
| } |
| } |
| } |
| } else { |
| // current choice has no separator, simply compare to the key |
| select = id.equals(current); |
| } |
| } |
| |
| String title = titles.get(i); |
| IAction a = new Action(title, |
| current != null ? IAction.AS_CHECK_BOX : IAction.AS_PUSH_BUTTON) { |
| @Override |
| public void runWithEvent(Event event) { |
| run(); |
| } |
| @Override |
| public void run() { |
| String label = createActionLabel(mParentAction, mNodes); |
| mEditorDelegate.getEditor().wrapUndoEditXmlModel(label, new Runnable() { |
| @Override |
| public void run() { |
| mParentAction.getCallback().action(mParentAction, mNodes, id, |
| Boolean.TRUE); |
| applyPendingChanges(); |
| } |
| }); |
| } |
| }; |
| a.setId(id); |
| a.setEnabled(true); |
| if (select) { |
| a.setChecked(true); |
| } |
| |
| new ActionContributionItem(a).fill(menu, -1); |
| } |
| } |
| } |
| } |
