| /* |
| * Copyright (C) 2008 The Android Open Source Project |
| * |
| * Licensed under the Apache License, Version 2.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.apache.org/licenses/LICENSE-2.0 |
| * |
| * 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.ui.tree; |
| |
| import com.android.ide.eclipse.adt.internal.editors.descriptors.DescriptorsUtils; |
| import com.android.ide.eclipse.adt.internal.editors.descriptors.ElementDescriptor; |
| import com.android.ide.eclipse.adt.internal.editors.descriptors.ElementDescriptor.Mandatory; |
| import com.android.ide.eclipse.adt.internal.editors.uimodel.UiDocumentNode; |
| import com.android.ide.eclipse.adt.internal.editors.uimodel.UiElementNode; |
| |
| import org.eclipse.jface.dialogs.MessageDialog; |
| import org.eclipse.jface.viewers.ILabelProvider; |
| import org.eclipse.swt.widgets.Shell; |
| import org.w3c.dom.Document; |
| import org.w3c.dom.Node; |
| |
| import java.util.List; |
| |
| /** |
| * Performs basic actions on an XML tree: add node, remove node, move up/down. |
| */ |
| public abstract class UiActions implements ICommitXml { |
| |
| public UiActions() { |
| } |
| |
| //--------------------- |
| // Actual implementations must override these to provide specific hooks |
| |
| /** Returns the UiDocumentNode for the current model. */ |
| abstract protected UiElementNode getRootNode(); |
| |
| /** Commits pending data before the XML model is modified. */ |
| @Override |
| abstract public void commitPendingXmlChanges(); |
| |
| /** |
| * Utility method to select an outline item based on its model node |
| * |
| * @param uiNode The node to select. Can be null (in which case nothing should happen) |
| */ |
| abstract protected void selectUiNode(UiElementNode uiNode); |
| |
| //--------------------- |
| |
| /** |
| * Called when the "Add..." button next to the tree view is selected. |
| * <p/> |
| * This simplified version of doAdd does not support descriptor filters and creates |
| * a new {@link UiModelTreeLabelProvider} for each call. |
| */ |
| public void doAdd(UiElementNode uiNode, Shell shell) { |
| doAdd(uiNode, null /* descriptorFilters */, shell, new UiModelTreeLabelProvider()); |
| } |
| |
| /** |
| * Called when the "Add..." button next to the tree view is selected. |
| * |
| * Displays a selection dialog that lets the user select which kind of node |
| * to create, depending on the current selection. |
| */ |
| public void doAdd(UiElementNode uiNode, |
| ElementDescriptor[] descriptorFilters, |
| Shell shell, ILabelProvider labelProvider) { |
| // If the root node is a document with already a root, use it as the root node |
| UiElementNode rootNode = getRootNode(); |
| if (rootNode instanceof UiDocumentNode && rootNode.getUiChildren().size() > 0) { |
| rootNode = rootNode.getUiChildren().get(0); |
| } |
| |
| NewItemSelectionDialog dlg = new NewItemSelectionDialog( |
| shell, |
| labelProvider, |
| descriptorFilters, |
| uiNode, rootNode); |
| dlg.open(); |
| Object[] results = dlg.getResult(); |
| if (results != null && results.length > 0) { |
| addElement(dlg.getChosenRootNode(), null, (ElementDescriptor) results[0], |
| true /*updateLayout*/); |
| } |
| } |
| |
| /** |
| * Adds a new XML element based on the {@link ElementDescriptor} to the given parent |
| * {@link UiElementNode}, and then select it. |
| * <p/> |
| * If the parent is a document root which already contains a root element, the inner |
| * root element is used as the actual parent. This ensure you can't create a broken |
| * XML file with more than one root element. |
| * <p/> |
| * If a sibling is given and that sibling has the same parent, the new node is added |
| * right after that sibling. Otherwise the new node is added at the end of the parent |
| * child list. |
| * |
| * @param uiParent An existing UI node or null to add to the tree root |
| * @param uiSibling An existing UI node before which to insert the new node. Can be null. |
| * @param descriptor The descriptor of the element to add |
| * @param updateLayout True if layout attributes should be set |
| * @return The new {@link UiElementNode} or null. |
| */ |
| public UiElementNode addElement(UiElementNode uiParent, |
| UiElementNode uiSibling, |
| ElementDescriptor descriptor, |
| boolean updateLayout) { |
| if (uiParent instanceof UiDocumentNode && uiParent.getUiChildren().size() > 0) { |
| uiParent = uiParent.getUiChildren().get(0); |
| } |
| if (uiSibling != null && uiSibling.getUiParent() != uiParent) { |
| uiSibling = null; |
| } |
| |
| UiElementNode uiNew = addNewTreeElement(uiParent, uiSibling, descriptor, updateLayout); |
| selectUiNode(uiNew); |
| |
| return uiNew; |
| } |
| |
| /** |
| * Called when the "Remove" button is selected. |
| * |
| * If the tree has a selection, remove it. |
| * This simply deletes the XML node attached to the UI node: when the XML model fires the |
| * update event, the tree will get refreshed. |
| */ |
| public void doRemove(final List<UiElementNode> nodes, Shell shell) { |
| |
| if (nodes == null || nodes.size() == 0) { |
| return; |
| } |
| |
| final int len = nodes.size(); |
| |
| StringBuilder sb = new StringBuilder(); |
| for (UiElementNode node : nodes) { |
| sb.append("\n- "); //$NON-NLS-1$ |
| sb.append(node.getBreadcrumbTrailDescription(false /* include_root */)); |
| } |
| |
| if (MessageDialog.openQuestion(shell, |
| len > 1 ? "Remove elements from Android XML" // title |
| : "Remove element from Android XML", |
| String.format("Do you really want to remove %1$s?", sb.toString()))) { |
| commitPendingXmlChanges(); |
| getRootNode().getEditor().wrapEditXmlModel(new Runnable() { |
| @Override |
| public void run() { |
| UiElementNode previous = null; |
| UiElementNode parent = null; |
| |
| for (int i = len - 1; i >= 0; i--) { |
| UiElementNode node = nodes.get(i); |
| previous = node.getUiPreviousSibling(); |
| parent = node.getUiParent(); |
| |
| // delete node |
| node.deleteXmlNode(); |
| } |
| |
| // try to select the last previous sibling or the last parent |
| if (previous != null) { |
| selectUiNode(previous); |
| } else if (parent != null) { |
| selectUiNode(parent); |
| } |
| } |
| }); |
| } |
| } |
| |
| /** |
| * Called when the "Up" button is selected. |
| * <p/> |
| * If the tree has a selection, move it up, either in the child list or as the last child |
| * of the previous parent. |
| */ |
| public void doUp( |
| final List<UiElementNode> uiNodes, |
| final ElementDescriptor[] descriptorFilters) { |
| if (uiNodes == null || uiNodes.size() < 1) { |
| return; |
| } |
| |
| final Node[] selectXmlNode = { null }; |
| final UiElementNode[] uiLastNode = { null }; |
| final UiElementNode[] uiSearchRoot = { null }; |
| |
| commitPendingXmlChanges(); |
| getRootNode().getEditor().wrapEditXmlModel(new Runnable() { |
| @Override |
| public void run() { |
| for (int i = 0; i < uiNodes.size(); i++) { |
| UiElementNode uiNode = uiLastNode[0] = uiNodes.get(i); |
| doUpInternal( |
| uiNode, |
| descriptorFilters, |
| selectXmlNode, |
| uiSearchRoot, |
| false /*testOnly*/); |
| } |
| } |
| }); |
| |
| assert uiLastNode[0] != null; // tell Eclipse this can't be null below |
| |
| if (selectXmlNode[0] == null) { |
| // The XML node has not been moved, we can just select the same UI node |
| selectUiNode(uiLastNode[0]); |
| } else { |
| // The XML node has moved. At this point the UI model has been reloaded |
| // and the XML node has been affected to a new UI node. Find that new UI |
| // node and select it. |
| if (uiSearchRoot[0] == null) { |
| uiSearchRoot[0] = uiLastNode[0].getUiRoot(); |
| } |
| if (uiSearchRoot[0] != null) { |
| selectUiNode(uiSearchRoot[0].findXmlNode(selectXmlNode[0])); |
| } |
| } |
| } |
| |
| /** |
| * Checks whether the "up" action can be performed on all items. |
| * |
| * @return True if the up action can be carried on *all* items. |
| */ |
| public boolean canDoUp( |
| List<UiElementNode> uiNodes, |
| ElementDescriptor[] descriptorFilters) { |
| if (uiNodes == null || uiNodes.size() < 1) { |
| return false; |
| } |
| |
| final Node[] selectXmlNode = { null }; |
| final UiElementNode[] uiSearchRoot = { null }; |
| |
| commitPendingXmlChanges(); |
| |
| for (int i = 0; i < uiNodes.size(); i++) { |
| if (!doUpInternal( |
| uiNodes.get(i), |
| descriptorFilters, |
| selectXmlNode, |
| uiSearchRoot, |
| true /*testOnly*/)) { |
| return false; |
| } |
| } |
| |
| return true; |
| } |
| |
| private boolean doUpInternal( |
| UiElementNode uiNode, |
| ElementDescriptor[] descriptorFilters, |
| Node[] outSelectXmlNode, |
| UiElementNode[] outUiSearchRoot, |
| boolean testOnly) { |
| // the node will move either up to its parent or grand-parent |
| outUiSearchRoot[0] = uiNode.getUiParent(); |
| if (outUiSearchRoot[0] != null && outUiSearchRoot[0].getUiParent() != null) { |
| outUiSearchRoot[0] = outUiSearchRoot[0].getUiParent(); |
| } |
| Node xmlNode = uiNode.getXmlNode(); |
| ElementDescriptor nodeDesc = uiNode.getDescriptor(); |
| if (xmlNode == null || nodeDesc == null) { |
| return false; |
| } |
| UiElementNode uiParentNode = uiNode.getUiParent(); |
| Node xmlParent = uiParentNode == null ? null : uiParentNode.getXmlNode(); |
| if (xmlParent == null) { |
| return false; |
| } |
| |
| UiElementNode uiPrev = uiNode.getUiPreviousSibling(); |
| |
| // Only accept a sibling that has an XML attached and |
| // is part of the allowed descriptor filters. |
| while (uiPrev != null && |
| (uiPrev.getXmlNode() == null || !matchDescFilter(descriptorFilters, uiPrev))) { |
| uiPrev = uiPrev.getUiPreviousSibling(); |
| } |
| |
| if (uiPrev != null && uiPrev.getXmlNode() != null) { |
| // This node is not the first one of the parent. |
| Node xmlPrev = uiPrev.getXmlNode(); |
| if (uiPrev.getDescriptor().acceptChild(nodeDesc)) { |
| // If the previous sibling can accept this child, then it |
| // is inserted at the end of the children list. |
| if (testOnly) { |
| return true; |
| } |
| xmlPrev.appendChild(xmlParent.removeChild(xmlNode)); |
| outSelectXmlNode[0] = xmlNode; |
| } else { |
| // This node is not the first one of the parent, so it can be |
| // removed and then inserted before its previous sibling. |
| if (testOnly) { |
| return true; |
| } |
| xmlParent.insertBefore( |
| xmlParent.removeChild(xmlNode), |
| xmlPrev); |
| outSelectXmlNode[0] = xmlNode; |
| } |
| } else if (uiParentNode != null && !(xmlParent instanceof Document)) { |
| UiElementNode uiGrandParent = uiParentNode.getUiParent(); |
| Node xmlGrandParent = uiGrandParent == null ? null : uiGrandParent.getXmlNode(); |
| ElementDescriptor grandDesc = |
| uiGrandParent == null ? null : uiGrandParent.getDescriptor(); |
| |
| if (xmlGrandParent != null && |
| !(xmlGrandParent instanceof Document) && |
| grandDesc != null && |
| grandDesc.acceptChild(nodeDesc)) { |
| // If the node is the first one of the child list of its |
| // parent, move it up in the hierarchy as previous sibling |
| // to the parent. This is only possible if the parent of the |
| // parent is not a document. |
| // The parent node must actually accept this kind of child. |
| |
| if (testOnly) { |
| return true; |
| } |
| xmlGrandParent.insertBefore( |
| xmlParent.removeChild(xmlNode), |
| xmlParent); |
| outSelectXmlNode[0] = xmlNode; |
| } |
| } |
| |
| return false; |
| } |
| |
| private boolean matchDescFilter( |
| ElementDescriptor[] descriptorFilters, |
| UiElementNode uiNode) { |
| if (descriptorFilters == null || descriptorFilters.length < 1) { |
| return true; |
| } |
| |
| ElementDescriptor desc = uiNode.getDescriptor(); |
| |
| for (ElementDescriptor filter : descriptorFilters) { |
| if (filter.equals(desc)) { |
| return true; |
| } |
| } |
| return false; |
| } |
| |
| /** |
| * Called when the "Down" button is selected. |
| * |
| * If the tree has a selection, move it down, either in the same child list or as the |
| * first child of the next parent. |
| */ |
| public void doDown( |
| final List<UiElementNode> nodes, |
| final ElementDescriptor[] descriptorFilters) { |
| if (nodes == null || nodes.size() < 1) { |
| return; |
| } |
| |
| final Node[] selectXmlNode = { null }; |
| final UiElementNode[] uiLastNode = { null }; |
| final UiElementNode[] uiSearchRoot = { null }; |
| |
| commitPendingXmlChanges(); |
| getRootNode().getEditor().wrapEditXmlModel(new Runnable() { |
| @Override |
| public void run() { |
| for (int i = nodes.size() - 1; i >= 0; i--) { |
| final UiElementNode node = uiLastNode[0] = nodes.get(i); |
| doDownInternal( |
| node, |
| descriptorFilters, |
| selectXmlNode, |
| uiSearchRoot, |
| false /*testOnly*/); |
| } |
| } |
| }); |
| |
| assert uiLastNode[0] != null; // tell Eclipse this can't be null below |
| |
| if (selectXmlNode[0] == null) { |
| // The XML node has not been moved, we can just select the same UI node |
| selectUiNode(uiLastNode[0]); |
| } else { |
| // The XML node has moved. At this point the UI model has been reloaded |
| // and the XML node has been affected to a new UI node. Find that new UI |
| // node and select it. |
| if (uiSearchRoot[0] == null) { |
| uiSearchRoot[0] = uiLastNode[0].getUiRoot(); |
| } |
| if (uiSearchRoot[0] != null) { |
| selectUiNode(uiSearchRoot[0].findXmlNode(selectXmlNode[0])); |
| } |
| } |
| } |
| |
| /** |
| * Checks whether the "down" action can be performed on all items. |
| * |
| * @return True if the down action can be carried on *all* items. |
| */ |
| public boolean canDoDown( |
| List<UiElementNode> uiNodes, |
| ElementDescriptor[] descriptorFilters) { |
| if (uiNodes == null || uiNodes.size() < 1) { |
| return false; |
| } |
| |
| final Node[] selectXmlNode = { null }; |
| final UiElementNode[] uiSearchRoot = { null }; |
| |
| commitPendingXmlChanges(); |
| |
| for (int i = 0; i < uiNodes.size(); i++) { |
| if (!doDownInternal( |
| uiNodes.get(i), |
| descriptorFilters, |
| selectXmlNode, |
| uiSearchRoot, |
| true /*testOnly*/)) { |
| return false; |
| } |
| } |
| |
| return true; |
| } |
| |
| private boolean doDownInternal( |
| UiElementNode uiNode, |
| ElementDescriptor[] descriptorFilters, |
| Node[] outSelectXmlNode, |
| UiElementNode[] outUiSearchRoot, |
| boolean testOnly) { |
| // the node will move either down to its parent or grand-parent |
| outUiSearchRoot[0] = uiNode.getUiParent(); |
| if (outUiSearchRoot[0] != null && outUiSearchRoot[0].getUiParent() != null) { |
| outUiSearchRoot[0] = outUiSearchRoot[0].getUiParent(); |
| } |
| |
| Node xmlNode = uiNode.getXmlNode(); |
| ElementDescriptor nodeDesc = uiNode.getDescriptor(); |
| if (xmlNode == null || nodeDesc == null) { |
| return false; |
| } |
| UiElementNode uiParentNode = uiNode.getUiParent(); |
| Node xmlParent = uiParentNode == null ? null : uiParentNode.getXmlNode(); |
| if (xmlParent == null) { |
| return false; |
| } |
| |
| UiElementNode uiNext = uiNode.getUiNextSibling(); |
| |
| // Only accept a sibling that has an XML attached and |
| // is part of the allowed descriptor filters. |
| while (uiNext != null && |
| (uiNext.getXmlNode() == null || !matchDescFilter(descriptorFilters, uiNext))) { |
| uiNext = uiNext.getUiNextSibling(); |
| } |
| |
| if (uiNext != null && uiNext.getXmlNode() != null) { |
| // This node is not the last one of the parent. |
| Node xmlNext = uiNext.getXmlNode(); |
| // If the next sibling is a node that can have children, though, |
| // then the node is inserted as the first child. |
| if (uiNext.getDescriptor().acceptChild(nodeDesc)) { |
| if (testOnly) { |
| return true; |
| } |
| // Note: insertBefore works as append if the ref node is |
| // null, i.e. when the node doesn't have children yet. |
| xmlNext.insertBefore( |
| xmlParent.removeChild(xmlNode), |
| xmlNext.getFirstChild()); |
| outSelectXmlNode[0] = xmlNode; |
| } else { |
| // This node is not the last one of the parent, so it can be |
| // removed and then inserted after its next sibling. |
| |
| if (testOnly) { |
| return true; |
| } |
| // Insert "before after next" ;-) |
| xmlParent.insertBefore( |
| xmlParent.removeChild(xmlNode), |
| xmlNext.getNextSibling()); |
| outSelectXmlNode[0] = xmlNode; |
| } |
| } else if (uiParentNode != null && !(xmlParent instanceof Document)) { |
| UiElementNode uiGrandParent = uiParentNode.getUiParent(); |
| Node xmlGrandParent = uiGrandParent == null ? null : uiGrandParent.getXmlNode(); |
| ElementDescriptor grandDesc = |
| uiGrandParent == null ? null : uiGrandParent.getDescriptor(); |
| |
| if (xmlGrandParent != null && |
| !(xmlGrandParent instanceof Document) && |
| grandDesc != null && |
| grandDesc.acceptChild(nodeDesc)) { |
| // This node is the last node of its parent. |
| // If neither the parent nor the grandparent is a document, |
| // then the node can be inserted right after the parent. |
| // The parent node must actually accept this kind of child. |
| if (testOnly) { |
| return true; |
| } |
| xmlGrandParent.insertBefore( |
| xmlParent.removeChild(xmlNode), |
| xmlParent.getNextSibling()); |
| outSelectXmlNode[0] = xmlNode; |
| } |
| } |
| |
| return false; |
| } |
| |
| //--------------------- |
| |
| /** |
| * Adds a new element of the given descriptor's type to the given UI parent node. |
| * |
| * This actually creates the corresponding XML node in the XML model, which in turn |
| * will refresh the current tree view. |
| * |
| * @param uiParent An existing UI node or null to add to the tree root |
| * @param uiSibling An existing UI node to insert right before. Can be null. |
| * @param descriptor The descriptor of the element to add |
| * @param updateLayout True if layout attributes should be set |
| * @return The {@link UiElementNode} that has been added to the UI tree. |
| */ |
| private UiElementNode addNewTreeElement(UiElementNode uiParent, |
| UiElementNode uiSibling, |
| ElementDescriptor descriptor, |
| final boolean updateLayout) { |
| commitPendingXmlChanges(); |
| |
| List<UiElementNode> uiChildren = uiParent.getUiChildren(); |
| int n = uiChildren.size(); |
| |
| // The default is to append at the end of the list. |
| int index = n; |
| |
| if (uiSibling != null) { |
| // Try to find the requested sibling. |
| index = uiChildren.indexOf(uiSibling); |
| if (index < 0) { |
| // This sibling didn't exist. Should not happen but compensate |
| // by simply adding to the end of the list. |
| uiSibling = null; |
| index = n; |
| } |
| } |
| |
| if (uiSibling == null) { |
| // If we don't require any specific position, make sure to insert before the |
| // first mandatory_last descriptor's position, if any. |
| |
| for (int i = 0; i < n; i++) { |
| UiElementNode uiChild = uiChildren.get(i); |
| if (uiChild.getDescriptor().getMandatory() == Mandatory.MANDATORY_LAST) { |
| index = i; |
| break; |
| } |
| } |
| } |
| |
| final UiElementNode uiNew = uiParent.insertNewUiChild(index, descriptor); |
| UiElementNode rootNode = getRootNode(); |
| |
| rootNode.getEditor().wrapEditXmlModel(new Runnable() { |
| @Override |
| public void run() { |
| DescriptorsUtils.setDefaultLayoutAttributes(uiNew, updateLayout); |
| uiNew.createXmlNode(); |
| } |
| }); |
| return uiNew; |
| } |
| } |
