| /* |
| * 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.FQCN_SPACE; |
| import static com.android.SdkConstants.FQCN_SPACE_V7; |
| import static com.android.SdkConstants.NEW_ID_PREFIX; |
| import static com.android.ide.eclipse.adt.internal.editors.layout.gle2.SelectionHandle.PIXEL_MARGIN; |
| import static com.android.ide.eclipse.adt.internal.editors.layout.gle2.SelectionHandle.PIXEL_RADIUS; |
| |
| import com.android.SdkConstants; |
| import com.android.annotations.NonNull; |
| import com.android.annotations.Nullable; |
| import com.android.ide.common.api.INode; |
| import com.android.ide.common.api.RuleAction; |
| import com.android.ide.common.layout.BaseViewRule; |
| import com.android.ide.common.layout.GridLayoutRule; |
| import com.android.ide.eclipse.adt.AdtPlugin; |
| import com.android.ide.eclipse.adt.internal.editors.descriptors.ElementDescriptor; |
| 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.gre.RulesEngine; |
| import com.android.ide.eclipse.adt.internal.editors.layout.uimodel.UiViewElementNode; |
| import com.android.ide.eclipse.adt.internal.editors.uimodel.UiElementNode; |
| import com.android.ide.eclipse.adt.internal.refactorings.core.RenameResourceWizard; |
| import com.android.ide.eclipse.adt.internal.refactorings.core.RenameResult; |
| import com.android.ide.eclipse.adt.internal.resources.ResourceNameValidator; |
| import com.android.resources.ResourceType; |
| import com.android.utils.Pair; |
| |
| import org.eclipse.core.resources.IProject; |
| import org.eclipse.core.runtime.ListenerList; |
| import org.eclipse.jface.action.Action; |
| import org.eclipse.jface.action.ActionContributionItem; |
| import org.eclipse.jface.action.IAction; |
| import org.eclipse.jface.action.Separator; |
| import org.eclipse.jface.dialogs.InputDialog; |
| import org.eclipse.jface.util.SafeRunnable; |
| import org.eclipse.jface.viewers.ISelection; |
| import org.eclipse.jface.viewers.ISelectionChangedListener; |
| import org.eclipse.jface.viewers.ISelectionProvider; |
| import org.eclipse.jface.viewers.ITreeSelection; |
| import org.eclipse.jface.viewers.SelectionChangedEvent; |
| import org.eclipse.jface.viewers.TreePath; |
| import org.eclipse.jface.viewers.TreeSelection; |
| import org.eclipse.jface.window.Window; |
| import org.eclipse.swt.SWT; |
| import org.eclipse.swt.events.MenuDetectEvent; |
| import org.eclipse.swt.events.MouseEvent; |
| import org.eclipse.swt.widgets.Display; |
| import org.eclipse.swt.widgets.Menu; |
| import org.eclipse.ui.IWorkbenchPartSite; |
| import org.w3c.dom.Node; |
| |
| import java.util.ArrayList; |
| import java.util.Collection; |
| import java.util.Collections; |
| import java.util.HashSet; |
| import java.util.Iterator; |
| import java.util.LinkedList; |
| import java.util.List; |
| import java.util.ListIterator; |
| import java.util.Set; |
| |
| /** |
| * The {@link SelectionManager} manages the selection in the canvas editor. |
| * It holds (and can be asked about) the set of selected items, and it also has |
| * operations for manipulating the selection - such as toggling items, copying |
| * the selection to the clipboard, etc. |
| * <p/> |
| * This class implements {@link ISelectionProvider} so that it can delegate |
| * the selection provider from the {@link LayoutCanvasViewer}. |
| * <p/> |
| * Note that {@link LayoutCanvasViewer} sets a selection change listener on this |
| * manager so that it can invoke its own fireSelectionChanged when the canvas' |
| * selection changes. |
| */ |
| public class SelectionManager implements ISelectionProvider { |
| |
| private LayoutCanvas mCanvas; |
| |
| /** The current selection list. The list is never null, however it can be empty. */ |
| private final LinkedList<SelectionItem> mSelections = new LinkedList<SelectionItem>(); |
| |
| /** An unmodifiable view of {@link #mSelections}. */ |
| private final List<SelectionItem> mUnmodifiableSelection = |
| Collections.unmodifiableList(mSelections); |
| |
| /** Barrier set when updating the selection to prevent from recursively |
| * invoking ourselves. */ |
| private boolean mInsideUpdateSelection; |
| |
| /** |
| * The <em>current</em> alternate selection, if any, which changes when the Alt key is |
| * used during a selection. Can be null. |
| */ |
| private CanvasAlternateSelection mAltSelection; |
| |
| /** List of clients listening to selection changes. */ |
| private final ListenerList mSelectionListeners = new ListenerList(); |
| |
| /** |
| * Constructs a new {@link SelectionManager} associated with the given layout canvas. |
| * |
| * @param layoutCanvas The layout canvas to create a {@link SelectionManager} for. |
| */ |
| public SelectionManager(LayoutCanvas layoutCanvas) { |
| mCanvas = layoutCanvas; |
| } |
| |
| @Override |
| public void addSelectionChangedListener(ISelectionChangedListener listener) { |
| mSelectionListeners.add(listener); |
| } |
| |
| @Override |
| public void removeSelectionChangedListener(ISelectionChangedListener listener) { |
| mSelectionListeners.remove(listener); |
| } |
| |
| /** |
| * Returns the native {@link SelectionItem} list. |
| * |
| * @return An immutable list of {@link SelectionItem}. Can be empty but not null. |
| */ |
| @NonNull |
| List<SelectionItem> getSelections() { |
| return mUnmodifiableSelection; |
| } |
| |
| /** |
| * Return a snapshot/copy of the selection. Useful for clipboards etc where we |
| * don't want the returned copy to be affected by future edits to the selection. |
| * |
| * @return A copy of the current selection. Never null. |
| */ |
| @NonNull |
| public List<SelectionItem> getSnapshot() { |
| if (mSelectionListeners.isEmpty()) { |
| return Collections.emptyList(); |
| } |
| |
| return new ArrayList<SelectionItem>(mSelections); |
| } |
| |
| /** |
| * Returns a {@link TreeSelection} where each {@link TreePath} item is |
| * actually a {@link CanvasViewInfo}. |
| */ |
| @Override |
| public ISelection getSelection() { |
| if (mSelections.isEmpty()) { |
| return TreeSelection.EMPTY; |
| } |
| |
| ArrayList<TreePath> paths = new ArrayList<TreePath>(); |
| |
| for (SelectionItem cs : mSelections) { |
| CanvasViewInfo vi = cs.getViewInfo(); |
| if (vi != null) { |
| paths.add(getTreePath(vi)); |
| } |
| } |
| |
| return new TreeSelection(paths.toArray(new TreePath[paths.size()])); |
| } |
| |
| /** |
| * Create a {@link TreePath} from the given view info |
| * |
| * @param viewInfo the view info to look up a tree path for |
| * @return a {@link TreePath} for the given view info |
| */ |
| public static TreePath getTreePath(CanvasViewInfo viewInfo) { |
| ArrayList<Object> segments = new ArrayList<Object>(); |
| while (viewInfo != null) { |
| segments.add(0, viewInfo); |
| viewInfo = viewInfo.getParent(); |
| } |
| |
| return new TreePath(segments.toArray()); |
| } |
| |
| /** |
| * Sets the selection. It must be an {@link ITreeSelection} where each segment |
| * of the tree path is a {@link CanvasViewInfo}. A null selection is considered |
| * as an empty selection. |
| * <p/> |
| * This method is invoked by {@link LayoutCanvasViewer#setSelection(ISelection)} |
| * in response to an <em>outside</em> selection (compatible with ours) that has |
| * changed. Typically it means the outline selection has changed and we're |
| * synchronizing ours to match. |
| */ |
| @Override |
| public void setSelection(ISelection selection) { |
| if (mInsideUpdateSelection) { |
| return; |
| } |
| |
| boolean changed = false; |
| try { |
| mInsideUpdateSelection = true; |
| |
| if (selection == null) { |
| selection = TreeSelection.EMPTY; |
| } |
| |
| if (selection instanceof ITreeSelection) { |
| ITreeSelection treeSel = (ITreeSelection) selection; |
| |
| if (treeSel.isEmpty()) { |
| // Clear existing selection, if any |
| if (!mSelections.isEmpty()) { |
| mSelections.clear(); |
| mAltSelection = null; |
| updateActionsFromSelection(); |
| redraw(); |
| } |
| return; |
| } |
| |
| boolean redoLayout = false; |
| |
| // Create a list of all currently selected view infos |
| Set<CanvasViewInfo> oldSelected = new HashSet<CanvasViewInfo>(); |
| for (SelectionItem cs : mSelections) { |
| oldSelected.add(cs.getViewInfo()); |
| } |
| |
| // Go thru new selection and take care of selecting new items |
| // or marking those which are the same as in the current selection |
| for (TreePath path : treeSel.getPaths()) { |
| Object seg = path.getLastSegment(); |
| if (seg instanceof CanvasViewInfo) { |
| CanvasViewInfo newVi = (CanvasViewInfo) seg; |
| if (oldSelected.contains(newVi)) { |
| // This view info is already selected. Remove it from the |
| // oldSelected list so that we don't deselect it later. |
| oldSelected.remove(newVi); |
| } else { |
| // This view info is not already selected. Select it now. |
| |
| // reset alternate selection if any |
| mAltSelection = null; |
| // otherwise add it. |
| mSelections.add(createSelection(newVi)); |
| changed = true; |
| } |
| if (newVi.isInvisible()) { |
| redoLayout = true; |
| } |
| } else { |
| // Unrelated selection (e.g. user clicked in the Project Explorer |
| // or something) -- just ignore these |
| return; |
| } |
| } |
| |
| // Deselect old selected items that are not in the new one |
| for (CanvasViewInfo vi : oldSelected) { |
| if (vi.isExploded()) { |
| redoLayout = true; |
| } |
| deselect(vi); |
| changed = true; |
| } |
| |
| if (redoLayout) { |
| mCanvas.getEditorDelegate().recomputeLayout(); |
| } |
| } |
| } finally { |
| mInsideUpdateSelection = false; |
| } |
| |
| if (changed) { |
| redraw(); |
| fireSelectionChanged(); |
| updateActionsFromSelection(); |
| } |
| } |
| |
| /** |
| * The menu has been activated; ensure that the menu click is over the existing |
| * selection, and if not, update the selection. |
| * |
| * @param e the {@link MenuDetectEvent} which triggered the menu |
| */ |
| public void menuClick(MenuDetectEvent e) { |
| LayoutPoint p = ControlPoint.create(mCanvas, e).toLayout(); |
| |
| // Right click button is used to display a context menu. |
| // If there's an existing selection and the click is anywhere in this selection |
| // and there are no modifiers being used, we don't want to change the selection. |
| // Otherwise we select the item under the cursor. |
| |
| for (SelectionItem cs : mSelections) { |
| if (cs.isRoot()) { |
| continue; |
| } |
| if (cs.getRect().contains(p.x, p.y)) { |
| // The cursor is inside the selection. Don't change anything. |
| return; |
| } |
| } |
| |
| CanvasViewInfo vi = mCanvas.getViewHierarchy().findViewInfoAt(p); |
| selectSingle(vi); |
| } |
| |
| /** |
| * Performs selection for a mouse event. |
| * <p/> |
| * Shift key (or Command on the Mac) is used to toggle in multi-selection. |
| * Alt key is used to cycle selection through objects at the same level than |
| * the one pointed at (i.e. click on an object then alt-click to cycle). |
| * |
| * @param e The mouse event which triggered the selection. Cannot be null. |
| * The modifier key mask will be used to determine whether this |
| * is a plain select or a toggle, etc. |
| */ |
| public void select(MouseEvent e) { |
| boolean isMultiClick = (e.stateMask & SWT.SHIFT) != 0 || |
| // On Mac, the Command key is the normal toggle accelerator |
| ((SdkConstants.CURRENT_PLATFORM == SdkConstants.PLATFORM_DARWIN) && |
| (e.stateMask & SWT.COMMAND) != 0); |
| boolean isCycleClick = (e.stateMask & SWT.ALT) != 0; |
| |
| LayoutPoint p = ControlPoint.create(mCanvas, e).toLayout(); |
| |
| if (e.button == 3) { |
| // Right click button is used to display a context menu. |
| // If there's an existing selection and the click is anywhere in this selection |
| // and there are no modifiers being used, we don't want to change the selection. |
| // Otherwise we select the item under the cursor. |
| |
| if (!isCycleClick && !isMultiClick) { |
| for (SelectionItem cs : mSelections) { |
| if (cs.getRect().contains(p.x, p.y)) { |
| // The cursor is inside the selection. Don't change anything. |
| return; |
| } |
| } |
| } |
| |
| } else if (e.button != 1) { |
| // Click was done with something else than the left button for normal selection |
| // or the right button for context menu. |
| // We don't use mouse button 2 yet (middle mouse, or scroll wheel?) for |
| // anything, so let's not change the selection. |
| return; |
| } |
| |
| CanvasViewInfo vi = mCanvas.getViewHierarchy().findViewInfoAt(p); |
| |
| if (vi != null && vi.isHidden()) { |
| vi = vi.getParent(); |
| } |
| |
| if (isMultiClick && !isCycleClick) { |
| // Case where shift is pressed: pointed object is toggled. |
| |
| // reset alternate selection if any |
| mAltSelection = null; |
| |
| // If nothing has been found at the cursor, assume it might be a user error |
| // and avoid clearing the existing selection. |
| |
| if (vi != null) { |
| // toggle this selection on-off: remove it if already selected |
| if (deselect(vi)) { |
| if (vi.isExploded()) { |
| mCanvas.getEditorDelegate().recomputeLayout(); |
| } |
| |
| redraw(); |
| return; |
| } |
| |
| // otherwise add it. |
| mSelections.add(createSelection(vi)); |
| fireSelectionChanged(); |
| redraw(); |
| } |
| |
| } else if (isCycleClick) { |
| // Case where alt is pressed: select or cycle the object pointed at. |
| |
| // Note: if shift and alt are pressed, shift is ignored. The alternate selection |
| // mechanism does not reset the current multiple selection unless they intersect. |
| |
| // We need to remember the "origin" of the alternate selection, to be |
| // able to continue cycling through it later. If there's no alternate selection, |
| // create one. If there's one but not for the same origin object, create a new |
| // one too. |
| if (mAltSelection == null || mAltSelection.getOriginatingView() != vi) { |
| mAltSelection = new CanvasAlternateSelection( |
| vi, mCanvas.getViewHierarchy().findAltViewInfoAt(p)); |
| |
| // deselect them all, in case they were partially selected |
| deselectAll(mAltSelection.getAltViews()); |
| |
| // select the current one |
| CanvasViewInfo vi2 = mAltSelection.getCurrent(); |
| if (vi2 != null) { |
| mSelections.addFirst(createSelection(vi2)); |
| fireSelectionChanged(); |
| } |
| } else { |
| // We're trying to cycle through the current alternate selection. |
| // First remove the current object. |
| CanvasViewInfo vi2 = mAltSelection.getCurrent(); |
| deselect(vi2); |
| |
| // Now select the next one. |
| vi2 = mAltSelection.getNext(); |
| if (vi2 != null) { |
| mSelections.addFirst(createSelection(vi2)); |
| fireSelectionChanged(); |
| } |
| } |
| redraw(); |
| |
| } else { |
| // Case where no modifier is pressed: either select or reset the selection. |
| selectSingle(vi); |
| } |
| } |
| |
| /** |
| * Removes all the currently selected item and only select the given item. |
| * Issues a redraw() if the selection changes. |
| * |
| * @param vi The new selected item if non-null. Selection becomes empty if null. |
| * @return the item selected, or null if the selection was cleared (e.g. vi was null) |
| */ |
| @Nullable |
| SelectionItem selectSingle(CanvasViewInfo vi) { |
| SelectionItem item = null; |
| |
| // reset alternate selection if any |
| mAltSelection = null; |
| |
| if (vi == null) { |
| // The user clicked outside the bounds of the root element; in that case, just |
| // select the root element. |
| vi = mCanvas.getViewHierarchy().getRoot(); |
| } |
| |
| boolean redoLayout = hasExplodedItems(); |
| |
| // reset (multi)selection if any |
| if (!mSelections.isEmpty()) { |
| if (mSelections.size() == 1 && mSelections.getFirst().getViewInfo() == vi) { |
| // CanvasSelection remains the same, don't touch it. |
| return mSelections.getFirst(); |
| } |
| mSelections.clear(); |
| } |
| |
| if (vi != null) { |
| item = createSelection(vi); |
| mSelections.add(item); |
| if (vi.isInvisible()) { |
| redoLayout = true; |
| } |
| } |
| fireSelectionChanged(); |
| |
| if (redoLayout) { |
| mCanvas.getEditorDelegate().recomputeLayout(); |
| } |
| |
| redraw(); |
| |
| return item; |
| } |
| |
| /** Returns true if the view hierarchy is showing exploded items. */ |
| private boolean hasExplodedItems() { |
| for (SelectionItem item : mSelections) { |
| if (item.getViewInfo().isExploded()) { |
| return true; |
| } |
| } |
| |
| return false; |
| } |
| |
| /** |
| * Selects the given set of {@link CanvasViewInfo}s. This is similar to |
| * {@link #selectSingle} but allows you to make a multi-selection. Issues a |
| * {@link #redraw()}. |
| * |
| * @param viewInfos A collection of {@link CanvasViewInfo} objects to be |
| * selected, or null or empty to clear the selection. |
| */ |
| /* package */ void selectMultiple(Collection<CanvasViewInfo> viewInfos) { |
| // reset alternate selection if any |
| mAltSelection = null; |
| |
| boolean redoLayout = hasExplodedItems(); |
| |
| mSelections.clear(); |
| if (viewInfos != null) { |
| for (CanvasViewInfo viewInfo : viewInfos) { |
| mSelections.add(createSelection(viewInfo)); |
| if (viewInfo.isInvisible()) { |
| redoLayout = true; |
| } |
| } |
| } |
| |
| fireSelectionChanged(); |
| |
| if (redoLayout) { |
| mCanvas.getEditorDelegate().recomputeLayout(); |
| } |
| |
| redraw(); |
| } |
| |
| public void select(Collection<INode> nodes) { |
| List<CanvasViewInfo> infos = new ArrayList<CanvasViewInfo>(nodes.size()); |
| for (INode node : nodes) { |
| CanvasViewInfo info = mCanvas.getViewHierarchy().findViewInfoFor(node); |
| if (info != null) { |
| infos.add(info); |
| } |
| } |
| selectMultiple(infos); |
| } |
| |
| /** |
| * Selects the visual element corresponding to the given XML node |
| * @param xmlNode The Node whose element we want to select. |
| */ |
| /* package */ void select(Node xmlNode) { |
| if (xmlNode == null) { |
| return; |
| } else if (xmlNode.getNodeType() == Node.TEXT_NODE) { |
| xmlNode = xmlNode.getParentNode(); |
| } |
| |
| CanvasViewInfo vi = mCanvas.getViewHierarchy().findViewInfoFor(xmlNode); |
| if (vi != null && !vi.isRoot()) { |
| selectSingle(vi); |
| } |
| } |
| |
| /** |
| * Selects any views that overlap the given selection rectangle. |
| * |
| * @param topLeft The top left corner defining the selection rectangle. |
| * @param bottomRight The bottom right corner defining the selection |
| * rectangle. |
| * @param toggled A set of {@link CanvasViewInfo}s that should be toggled |
| * rather than just added. |
| */ |
| public void selectWithin(LayoutPoint topLeft, LayoutPoint bottomRight, |
| Collection<CanvasViewInfo> toggled) { |
| // reset alternate selection if any |
| mAltSelection = null; |
| |
| ViewHierarchy viewHierarchy = mCanvas.getViewHierarchy(); |
| Collection<CanvasViewInfo> viewInfos = viewHierarchy.findWithin(topLeft, bottomRight); |
| |
| if (toggled.size() > 0) { |
| // Copy; we're not allowed to touch the passed in collection |
| Set<CanvasViewInfo> result = new HashSet<CanvasViewInfo>(toggled); |
| for (CanvasViewInfo viewInfo : viewInfos) { |
| if (toggled.contains(viewInfo)) { |
| result.remove(viewInfo); |
| } else { |
| result.add(viewInfo); |
| } |
| } |
| viewInfos = result; |
| } |
| |
| mSelections.clear(); |
| for (CanvasViewInfo viewInfo : viewInfos) { |
| if (viewInfo.isHidden()) { |
| continue; |
| } |
| mSelections.add(createSelection(viewInfo)); |
| } |
| |
| fireSelectionChanged(); |
| redraw(); |
| } |
| |
| /** |
| * Clears the selection and then selects everything (all views and all their |
| * children). |
| */ |
| public void selectAll() { |
| // First clear the current selection, if any. |
| mSelections.clear(); |
| mAltSelection = null; |
| |
| // Now select everything if there's a valid layout |
| for (CanvasViewInfo vi : mCanvas.getViewHierarchy().findAllViewInfos(false)) { |
| mSelections.add(createSelection(vi)); |
| } |
| |
| fireSelectionChanged(); |
| redraw(); |
| } |
| |
| /** Clears the selection */ |
| public void selectNone() { |
| mSelections.clear(); |
| mAltSelection = null; |
| fireSelectionChanged(); |
| redraw(); |
| } |
| |
| /** Selects the parent of the current selection */ |
| public void selectParent() { |
| if (mSelections.size() == 1) { |
| CanvasViewInfo parent = mSelections.get(0).getViewInfo().getParent(); |
| if (parent != null) { |
| selectSingle(parent); |
| } |
| } |
| } |
| |
| /** Finds all widgets in the layout that have the same type as the primary */ |
| public void selectSameType() { |
| // Find all |
| if (mSelections.size() == 1) { |
| CanvasViewInfo viewInfo = mSelections.get(0).getViewInfo(); |
| ElementDescriptor descriptor = viewInfo.getUiViewNode().getDescriptor(); |
| mSelections.clear(); |
| mAltSelection = null; |
| addSameType(mCanvas.getViewHierarchy().getRoot(), descriptor); |
| fireSelectionChanged(); |
| redraw(); |
| } |
| } |
| |
| /** Helper for {@link #selectSameType} */ |
| private void addSameType(CanvasViewInfo root, ElementDescriptor descriptor) { |
| if (root.getUiViewNode().getDescriptor() == descriptor) { |
| mSelections.add(createSelection(root)); |
| } |
| |
| for (CanvasViewInfo child : root.getChildren()) { |
| addSameType(child, descriptor); |
| } |
| } |
| |
| /** Selects the siblings of the primary */ |
| public void selectSiblings() { |
| // Find all |
| if (mSelections.size() == 1) { |
| CanvasViewInfo vi = mSelections.get(0).getViewInfo(); |
| mSelections.clear(); |
| mAltSelection = null; |
| CanvasViewInfo parent = vi.getParent(); |
| if (parent == null) { |
| selectNone(); |
| } else { |
| for (CanvasViewInfo child : parent.getChildren()) { |
| mSelections.add(createSelection(child)); |
| } |
| fireSelectionChanged(); |
| redraw(); |
| } |
| } |
| } |
| |
| /** |
| * Returns true if and only if there is currently more than one selected |
| * item. |
| * |
| * @return True if more than one item is selected |
| */ |
| public boolean hasMultiSelection() { |
| return mSelections.size() > 1; |
| } |
| |
| /** |
| * Deselects a view info. Returns true if the object was actually selected. |
| * Callers are responsible for calling redraw() and updateOulineSelection() |
| * after. |
| * @param canvasViewInfo The item to deselect. |
| * @return True if the object was successfully removed from the selection. |
| */ |
| public boolean deselect(CanvasViewInfo canvasViewInfo) { |
| if (canvasViewInfo == null) { |
| return false; |
| } |
| |
| for (ListIterator<SelectionItem> it = mSelections.listIterator(); it.hasNext(); ) { |
| SelectionItem s = it.next(); |
| if (canvasViewInfo == s.getViewInfo()) { |
| it.remove(); |
| return true; |
| } |
| } |
| |
| return false; |
| } |
| |
| /** |
| * Deselects multiple view infos. |
| * Callers are responsible for calling redraw() and updateOulineSelection() after. |
| */ |
| private void deselectAll(List<CanvasViewInfo> canvasViewInfos) { |
| for (ListIterator<SelectionItem> it = mSelections.listIterator(); it.hasNext(); ) { |
| SelectionItem s = it.next(); |
| if (canvasViewInfos.contains(s.getViewInfo())) { |
| it.remove(); |
| } |
| } |
| } |
| |
| /** Sync the selection with an updated view info tree */ |
| void sync() { |
| // Check if the selection is still the same (based on the object keys) |
| // and eventually recompute their bounds. |
| for (ListIterator<SelectionItem> it = mSelections.listIterator(); it.hasNext(); ) { |
| SelectionItem s = it.next(); |
| |
| // Check if the selected object still exists |
| ViewHierarchy viewHierarchy = mCanvas.getViewHierarchy(); |
| UiViewElementNode key = s.getViewInfo().getUiViewNode(); |
| CanvasViewInfo vi = viewHierarchy.findViewInfoFor(key); |
| |
| // Remove the previous selection -- if the selected object still exists |
| // we need to recompute its bounds in case it moved so we'll insert a new one |
| // at the same place. |
| it.remove(); |
| if (vi == null) { |
| vi = findCorresponding(s.getViewInfo(), viewHierarchy.getRoot()); |
| } |
| if (vi != null) { |
| it.add(createSelection(vi)); |
| } |
| } |
| fireSelectionChanged(); |
| |
| // remove the current alternate selection views |
| mAltSelection = null; |
| } |
| |
| /** Finds the corresponding {@link CanvasViewInfo} in the new hierarchy */ |
| private CanvasViewInfo findCorresponding(CanvasViewInfo old, CanvasViewInfo newRoot) { |
| CanvasViewInfo oldParent = old.getParent(); |
| if (oldParent != null) { |
| CanvasViewInfo newParent = findCorresponding(oldParent, newRoot); |
| if (newParent == null) { |
| return null; |
| } |
| |
| List<CanvasViewInfo> oldSiblings = oldParent.getChildren(); |
| List<CanvasViewInfo> newSiblings = newParent.getChildren(); |
| Iterator<CanvasViewInfo> oldIterator = oldSiblings.iterator(); |
| Iterator<CanvasViewInfo> newIterator = newSiblings.iterator(); |
| while (oldIterator.hasNext() && newIterator.hasNext()) { |
| CanvasViewInfo oldSibling = oldIterator.next(); |
| CanvasViewInfo newSibling = newIterator.next(); |
| |
| if (oldSibling.getName().equals(newSibling.getName())) { |
| // Structure has changed: can't do a proper search |
| return null; |
| } |
| |
| if (oldSibling == old) { |
| return newSibling; |
| } |
| } |
| } else { |
| return newRoot; |
| } |
| |
| return null; |
| } |
| |
| /** |
| * Notifies listeners that the selection has changed. |
| */ |
| private void fireSelectionChanged() { |
| if (mInsideUpdateSelection) { |
| return; |
| } |
| try { |
| mInsideUpdateSelection = true; |
| |
| final SelectionChangedEvent event = new SelectionChangedEvent(this, getSelection()); |
| |
| SafeRunnable.run(new SafeRunnable() { |
| @Override |
| public void run() { |
| for (Object listener : mSelectionListeners.getListeners()) { |
| ((ISelectionChangedListener) listener).selectionChanged(event); |
| } |
| } |
| }); |
| |
| updateActionsFromSelection(); |
| } finally { |
| mInsideUpdateSelection = false; |
| } |
| } |
| |
| /** |
| * Updates menu actions and the layout action bar after a selection change - these are |
| * actions that depend on the selection |
| */ |
| private void updateActionsFromSelection() { |
| LayoutEditorDelegate editor = mCanvas.getEditorDelegate(); |
| if (editor != null) { |
| // Update menu actions that depend on the selection |
| mCanvas.updateMenuActionState(); |
| |
| // Update the layout actions bar |
| LayoutActionBar layoutActionBar = editor.getGraphicalEditor().getLayoutActionBar(); |
| layoutActionBar.updateSelection(); |
| } |
| } |
| |
| /** |
| * Sanitizes the selection for a copy/cut or drag operation. |
| * <p/> |
| * Sanitizes the list to make sure all elements have a valid XML attached to it, |
| * that is remove element that have no XML to avoid having to make repeated such |
| * checks in various places after. |
| * <p/> |
| * In case of multiple selection, we also need to remove all children when their |
| * parent is already selected since parents will always be added with all their |
| * children. |
| * <p/> |
| * |
| * @param selection The selection list to be sanitized <b>in-place</b>. |
| * The <code>selection</code> argument should not be {@link #mSelections} -- the |
| * given list is going to be altered and we should never alter the user-made selection. |
| * Instead the caller should provide its own copy. |
| */ |
| /* package */ static void sanitize(List<SelectionItem> selection) { |
| if (selection.isEmpty()) { |
| return; |
| } |
| |
| for (Iterator<SelectionItem> it = selection.iterator(); it.hasNext(); ) { |
| SelectionItem cs = it.next(); |
| CanvasViewInfo vi = cs.getViewInfo(); |
| UiViewElementNode key = vi == null ? null : vi.getUiViewNode(); |
| Node node = key == null ? null : key.getXmlNode(); |
| if (node == null) { |
| // Missing ViewInfo or view key or XML, discard this. |
| it.remove(); |
| continue; |
| } |
| |
| if (vi != null) { |
| for (Iterator<SelectionItem> it2 = selection.iterator(); |
| it2.hasNext(); ) { |
| SelectionItem cs2 = it2.next(); |
| if (cs != cs2) { |
| CanvasViewInfo vi2 = cs2.getViewInfo(); |
| if (vi.isParent(vi2)) { |
| // vi2 is a parent for vi. Remove vi. |
| it.remove(); |
| break; |
| } |
| } |
| } |
| } |
| } |
| } |
| |
| /** |
| * Selects the given list of nodes in the canvas, and returns true iff the |
| * attempt to select was successful. |
| * |
| * @param nodes The collection of nodes to be selected |
| * @param indices A list of indices within the parent for each node, or null |
| * @return True if and only if all nodes were successfully selected |
| */ |
| public boolean selectDropped(List<INode> nodes, List<Integer> indices) { |
| assert indices == null || nodes.size() == indices.size(); |
| |
| ViewHierarchy viewHierarchy = mCanvas.getViewHierarchy(); |
| |
| // Look up a list of view infos which correspond to the nodes. |
| final Collection<CanvasViewInfo> newChildren = new ArrayList<CanvasViewInfo>(); |
| for (int i = 0, n = nodes.size(); i < n; i++) { |
| INode node = nodes.get(i); |
| |
| CanvasViewInfo viewInfo = viewHierarchy.findViewInfoFor(node); |
| |
| // There are two scenarios where looking up a view info fails. |
| // The first one is that the node was just added and the render has not yet |
| // happened, so the ViewHierarchy has no record of the node. In this case |
| // there is nothing we can do, and the method will return false (which the |
| // caller will use to schedule a second attempt later). |
| // The second scenario is where the nodes *change identity*. This isn't |
| // common, but when a drop handler makes a lot of changes to its children, |
| // for example when dropping into a GridLayout where attributes are adjusted |
| // on nearly all the other children to update row or column attributes |
| // etc, then in some cases Eclipse's DOM model changes the identities of |
| // the nodes when applying all the edits, so the new Node we created (as |
| // well as possibly other nodes) are no longer the children we observe |
| // after the edit, and there are new copies there instead. In this case |
| // the UiViewModel also fails to map the nodes. To work around this, |
| // we track the *indices* (within the parent) during a drop, such that we |
| // know which children (according to their positions) the given nodes |
| // are supposed to map to, and then we use these view infos instead. |
| if (viewInfo == null && node instanceof NodeProxy && indices != null) { |
| INode parent = node.getParent(); |
| CanvasViewInfo parentViewInfo = viewHierarchy.findViewInfoFor(parent); |
| if (parentViewInfo != null) { |
| UiViewElementNode parentUiNode = parentViewInfo.getUiViewNode(); |
| if (parentUiNode != null) { |
| List<UiElementNode> children = parentUiNode.getUiChildren(); |
| int index = indices.get(i); |
| if (index >= 0 && index < children.size()) { |
| UiElementNode replacedNode = children.get(index); |
| viewInfo = viewHierarchy.findViewInfoFor(replacedNode); |
| } |
| } |
| } |
| } |
| |
| if (viewInfo != null) { |
| if (nodes.size() > 1 && viewInfo.isHidden()) { |
| // Skip spacers - unless you're dropping just one |
| continue; |
| } |
| if (GridLayoutRule.sDebugGridLayout && (viewInfo.getName().equals(FQCN_SPACE) |
| || viewInfo.getName().equals(FQCN_SPACE_V7))) { |
| // In debug mode they might not be marked as hidden but we never never |
| // want to select these guys |
| continue; |
| } |
| newChildren.add(viewInfo); |
| } |
| } |
| boolean found = nodes.size() == newChildren.size(); |
| |
| if (found || newChildren.size() > 0) { |
| mCanvas.getSelectionManager().selectMultiple(newChildren); |
| } |
| |
| return found; |
| } |
| |
| /** |
| * Update the outline selection to select the given nodes, asynchronously. |
| * @param nodes The nodes to be selected |
| */ |
| public void setOutlineSelection(final List<INode> nodes) { |
| Display.getDefault().asyncExec(new Runnable() { |
| @Override |
| public void run() { |
| selectDropped(nodes, null /* indices */); |
| syncOutlineSelection(); |
| } |
| }); |
| } |
| |
| /** |
| * Syncs the current selection to the outline, synchronously. |
| */ |
| public void syncOutlineSelection() { |
| OutlinePage outlinePage = mCanvas.getOutlinePage(); |
| IWorkbenchPartSite site = outlinePage.getEditor().getSite(); |
| ISelectionProvider selectionProvider = site.getSelectionProvider(); |
| ISelection selection = selectionProvider.getSelection(); |
| if (selection != null) { |
| outlinePage.setSelection(selection); |
| } |
| } |
| |
| private void redraw() { |
| mCanvas.redraw(); |
| } |
| |
| SelectionItem createSelection(CanvasViewInfo vi) { |
| return new SelectionItem(mCanvas, vi); |
| } |
| |
| /** |
| * Returns true if there is nothing selected |
| * |
| * @return true if there is nothing selected |
| */ |
| public boolean isEmpty() { |
| return mSelections.size() == 0; |
| } |
| |
| /** |
| * "Select" context menu which lists various menu options related to selection: |
| * <ul> |
| * <li> Select All |
| * <li> Select Parent |
| * <li> Select None |
| * <li> Select Siblings |
| * <li> Select Same Type |
| * </ul> |
| * etc. |
| */ |
| public static class SelectionMenu extends SubmenuAction { |
| private final GraphicalEditorPart mEditor; |
| |
| public SelectionMenu(GraphicalEditorPart editor) { |
| super("Select"); |
| mEditor = editor; |
| } |
| |
| @Override |
| public String getId() { |
| return "-selectionmenu"; //$NON-NLS-1$ |
| } |
| |
| @Override |
| protected void addMenuItems(Menu menu) { |
| LayoutCanvas canvas = mEditor.getCanvasControl(); |
| SelectionManager selectionManager = canvas.getSelectionManager(); |
| List<SelectionItem> selections = selectionManager.getSelections(); |
| boolean selectedOne = selections.size() == 1; |
| boolean notRoot = selectedOne && !selections.get(0).isRoot(); |
| boolean haveSelection = selections.size() > 0; |
| |
| Action a; |
| a = selectionManager.new SelectAction("Select Parent\tEsc", SELECT_PARENT); |
| new ActionContributionItem(a).fill(menu, -1); |
| a.setEnabled(notRoot); |
| a.setAccelerator(SWT.ESC); |
| |
| a = selectionManager.new SelectAction("Select Siblings", SELECT_SIBLINGS); |
| new ActionContributionItem(a).fill(menu, -1); |
| a.setEnabled(notRoot); |
| |
| a = selectionManager.new SelectAction("Select Same Type", SELECT_SAME_TYPE); |
| new ActionContributionItem(a).fill(menu, -1); |
| a.setEnabled(selectedOne); |
| |
| new Separator().fill(menu, -1); |
| |
| // Special case for Select All: Use global action |
| a = canvas.getSelectAllAction(); |
| new ActionContributionItem(a).fill(menu, -1); |
| a.setEnabled(true); |
| |
| a = selectionManager.new SelectAction("Deselect All", SELECT_NONE); |
| new ActionContributionItem(a).fill(menu, -1); |
| a.setEnabled(haveSelection); |
| } |
| } |
| |
| private static final int SELECT_PARENT = 1; |
| private static final int SELECT_SIBLINGS = 2; |
| private static final int SELECT_SAME_TYPE = 3; |
| private static final int SELECT_NONE = 4; // SELECT_ALL is handled separately |
| |
| private class SelectAction extends Action { |
| private final int mType; |
| |
| public SelectAction(String title, int type) { |
| super(title, IAction.AS_PUSH_BUTTON); |
| mType = type; |
| } |
| |
| @Override |
| public void run() { |
| switch (mType) { |
| case SELECT_NONE: |
| selectNone(); |
| break; |
| case SELECT_PARENT: |
| selectParent(); |
| break; |
| case SELECT_SAME_TYPE: |
| selectSameType(); |
| break; |
| case SELECT_SIBLINGS: |
| selectSiblings(); |
| break; |
| } |
| |
| List<INode> nodes = new ArrayList<INode>(); |
| for (SelectionItem item : getSelections()) { |
| nodes.add(item.getNode()); |
| } |
| setOutlineSelection(nodes); |
| } |
| } |
| |
| public Pair<SelectionItem, SelectionHandle> findHandle(ControlPoint controlPoint) { |
| if (!isEmpty()) { |
| LayoutPoint layoutPoint = controlPoint.toLayout(); |
| int distance = (int) ((PIXEL_MARGIN + PIXEL_RADIUS) / mCanvas.getScale()); |
| |
| for (SelectionItem item : getSelections()) { |
| SelectionHandles handles = item.getSelectionHandles(); |
| // See if it's over the selection handles |
| SelectionHandle handle = handles.findHandle(layoutPoint, distance); |
| if (handle != null) { |
| return Pair.of(item, handle); |
| } |
| } |
| |
| } |
| return null; |
| } |
| |
| /** Performs the default action provided by the currently selected view */ |
| public void performDefaultAction() { |
| final List<SelectionItem> selections = getSelections(); |
| if (selections.size() > 0) { |
| NodeProxy primary = selections.get(0).getNode(); |
| if (primary != null) { |
| RulesEngine rulesEngine = mCanvas.getRulesEngine(); |
| final String id = rulesEngine.callGetDefaultActionId(primary); |
| if (id == null) { |
| return; |
| } |
| final List<RuleAction> actions = rulesEngine.callGetContextMenu(primary); |
| if (actions == null) { |
| return; |
| } |
| RuleAction matching = null; |
| for (RuleAction a : actions) { |
| if (id.equals(a.getId())) { |
| matching = a; |
| break; |
| } |
| } |
| if (matching == null) { |
| return; |
| } |
| final List<INode> selectedNodes = new ArrayList<INode>(); |
| for (SelectionItem item : selections) { |
| NodeProxy n = item.getNode(); |
| if (n != null) { |
| selectedNodes.add(n); |
| } |
| } |
| final RuleAction action = matching; |
| mCanvas.getEditorDelegate().getEditor().wrapUndoEditXmlModel(action.getTitle(), |
| new Runnable() { |
| @Override |
| public void run() { |
| action.getCallback().action(action, selectedNodes, |
| action.getId(), null); |
| LayoutCanvas canvas = mCanvas; |
| 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(); |
| } |
| } |
| } |
| }); |
| } |
| } |
| } |
| |
| /** Performs renaming the selected views */ |
| public void performRename() { |
| final List<SelectionItem> selections = getSelections(); |
| if (selections.size() > 0) { |
| NodeProxy primary = selections.get(0).getNode(); |
| if (primary != null) { |
| performRename(primary, selections); |
| } |
| } |
| } |
| |
| /** |
| * Performs renaming the given node. |
| * |
| * @param primary the node to be renamed, or the primary node (to get the |
| * current value from if more than one node should be renamed) |
| * @param selections if not null, a list of nodes to apply the setting to |
| * (which should include the primary) |
| * @return the result of the renaming operation |
| */ |
| @NonNull |
| public RenameResult performRename( |
| final @NonNull INode primary, |
| final @Nullable List<SelectionItem> selections) { |
| String id = primary.getStringAttr(ANDROID_URI, ATTR_ID); |
| if (id != null && !id.isEmpty()) { |
| RenameResult result = RenameResourceWizard.renameResource( |
| mCanvas.getShell(), |
| mCanvas.getEditorDelegate().getGraphicalEditor().getProject(), |
| ResourceType.ID, BaseViewRule.stripIdPrefix(id), null, true /*canClear*/); |
| if (result.isCanceled()) { |
| return result; |
| } else if (!result.isUnavailable()) { |
| return result; |
| } |
| } |
| String currentId = primary.getStringAttr(ANDROID_URI, ATTR_ID); |
| currentId = BaseViewRule.stripIdPrefix(currentId); |
| InputDialog d = new InputDialog( |
| AdtPlugin.getDisplay().getActiveShell(), |
| "Set ID", |
| "New ID:", |
| currentId, |
| ResourceNameValidator.create(false, (IProject) null, ResourceType.ID)); |
| if (d.open() == Window.OK) { |
| final String s = d.getValue(); |
| mCanvas.getEditorDelegate().getEditor().wrapUndoEditXmlModel("Set ID", |
| new Runnable() { |
| @Override |
| public void run() { |
| String newId = s; |
| newId = NEW_ID_PREFIX + BaseViewRule.stripIdPrefix(s); |
| if (selections != null) { |
| for (SelectionItem item : selections) { |
| NodeProxy node = item.getNode(); |
| if (node != null) { |
| node.setAttribute(ANDROID_URI, ATTR_ID, newId); |
| } |
| } |
| } else { |
| primary.setAttribute(ANDROID_URI, ATTR_ID, newId); |
| } |
| |
| LayoutCanvas canvas = mCanvas; |
| 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(); |
| } |
| } |
| } |
| }); |
| return RenameResult.name(BaseViewRule.stripIdPrefix(s)); |
| } else { |
| return RenameResult.canceled(); |
| } |
| } |
| } |
