Java tutorial
/* * 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; } }