| /* |
| * Copyright (C) 2007 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.uimodel; |
| |
| import static com.android.SdkConstants.ANDROID_PKG_PREFIX; |
| import static com.android.SdkConstants.ANDROID_SUPPORT_PKG_PREFIX; |
| import static com.android.SdkConstants.ATTR_CLASS; |
| import static com.android.SdkConstants.ID_PREFIX; |
| import static com.android.SdkConstants.NEW_ID_PREFIX; |
| |
| import com.android.SdkConstants; |
| import com.android.annotations.VisibleForTesting; |
| import com.android.ide.common.api.IAttributeInfo.Format; |
| import com.android.ide.common.resources.platform.AttributeInfo; |
| import com.android.ide.common.xml.XmlAttributeSortOrder; |
| import com.android.ide.eclipse.adt.AdtPlugin; |
| import com.android.ide.eclipse.adt.internal.editors.AndroidXmlEditor; |
| import com.android.ide.eclipse.adt.internal.editors.descriptors.AttributeDescriptor; |
| 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.descriptors.IUnknownDescriptorProvider; |
| import com.android.ide.eclipse.adt.internal.editors.descriptors.SeparatorAttributeDescriptor; |
| import com.android.ide.eclipse.adt.internal.editors.descriptors.TextAttributeDescriptor; |
| import com.android.ide.eclipse.adt.internal.editors.descriptors.XmlnsAttributeDescriptor; |
| import com.android.ide.eclipse.adt.internal.editors.layout.descriptors.CustomViewDescriptorService; |
| import com.android.ide.eclipse.adt.internal.editors.manifest.descriptors.AndroidManifestDescriptors; |
| import com.android.ide.eclipse.adt.internal.editors.otherxml.descriptors.OtherXmlDescriptors; |
| import com.android.ide.eclipse.adt.internal.editors.uimodel.IUiUpdateListener.UiUpdateState; |
| import com.android.ide.eclipse.adt.internal.preferences.AdtPrefs; |
| import com.android.ide.eclipse.adt.internal.sdk.AndroidTargetData; |
| import com.android.utils.SdkUtils; |
| import com.android.utils.XmlUtils; |
| |
| import org.eclipse.jface.text.TextUtilities; |
| import org.eclipse.jface.viewers.StyledString; |
| import org.eclipse.ui.views.properties.IPropertyDescriptor; |
| import org.eclipse.ui.views.properties.IPropertySource; |
| import org.eclipse.wst.sse.core.internal.provisional.text.IStructuredDocument; |
| import org.eclipse.wst.xml.core.internal.document.ElementImpl; |
| import org.w3c.dom.Attr; |
| import org.w3c.dom.Document; |
| import org.w3c.dom.Element; |
| import org.w3c.dom.NamedNodeMap; |
| import org.w3c.dom.Node; |
| import org.w3c.dom.Text; |
| |
| import java.util.ArrayList; |
| import java.util.Collection; |
| import java.util.Collections; |
| import java.util.HashMap; |
| import java.util.HashSet; |
| import java.util.List; |
| import java.util.Locale; |
| import java.util.Map; |
| import java.util.Map.Entry; |
| import java.util.Set; |
| |
| /** |
| * Represents an XML node that can be modified by the user interface in the XML editor. |
| * <p/> |
| * Each tree viewer used in the application page's parts needs to keep a model representing |
| * each underlying node in the tree. This interface represents the base type for such a node. |
| * <p/> |
| * Each node acts as an intermediary model between the actual XML model (the real data support) |
| * and the tree viewers or the corresponding page parts. |
| * <p/> |
| * Element nodes don't contain data per se. Their data is contained in their attributes |
| * as well as their children's attributes, see {@link UiAttributeNode}. |
| * <p/> |
| * The structure of a given {@link UiElementNode} is declared by a corresponding |
| * {@link ElementDescriptor}. |
| * <p/> |
| * The class implements {@link IPropertySource}, in order to fill the Eclipse property tab when |
| * an element is selected. The {@link AttributeDescriptor} are used property descriptors. |
| */ |
| @SuppressWarnings("restriction") // XML model |
| public class UiElementNode implements IPropertySource { |
| |
| /** List of prefixes removed from android:id strings when creating short descriptions. */ |
| private static String[] ID_PREFIXES = { |
| "@android:id/", //$NON-NLS-1$ |
| NEW_ID_PREFIX, ID_PREFIX, "@+", "@" }; //$NON-NLS-1$ //$NON-NLS-2$ |
| |
| /** The element descriptor for the node. Always present, never null. */ |
| private ElementDescriptor mDescriptor; |
| /** The parent element node in the UI model. It is null for a root element or until |
| * the node is attached to its parent. */ |
| private UiElementNode mUiParent; |
| /** The {@link AndroidXmlEditor} handling the UI hierarchy. This is defined only for the |
| * root node. All children have the value set to null and query their parent. */ |
| private AndroidXmlEditor mEditor; |
| /** The XML {@link Document} model that is being mirror by the UI model. This is defined |
| * only for the root node. All children have the value set to null and query their parent. */ |
| private Document mXmlDocument; |
| /** The XML {@link Node} mirror by this UI node. This can be null for mandatory UI node which |
| * have no corresponding XML node or for new UI nodes before their XML node is set. */ |
| private Node mXmlNode; |
| /** The list of all UI children nodes. Can be empty but never null. There's one UI children |
| * node per existing XML children node. */ |
| private ArrayList<UiElementNode> mUiChildren; |
| /** The list of <em>all</em> UI attributes, as declared in the {@link ElementDescriptor}. |
| * The list is always defined and never null. Unlike the UiElementNode children list, this |
| * is always defined, even for attributes that do not exist in the XML model - that's because |
| * "missing" attributes in the XML model simply mean a default value is used. Also note that |
| * the underlying collection is a map, so order is not respected. To get the desired attribute |
| * order, iterate through the {@link ElementDescriptor}'s attribute list. */ |
| private HashMap<AttributeDescriptor, UiAttributeNode> mUiAttributes; |
| private HashSet<UiAttributeNode> mUnknownUiAttributes; |
| /** A read-only view of the UI children node collection. */ |
| private List<UiElementNode> mReadOnlyUiChildren; |
| /** A read-only view of the UI attributes collection. */ |
| private Collection<UiAttributeNode> mCachedAllUiAttributes; |
| /** A map of hidden attribute descriptors. Key is the XML name. */ |
| private Map<String, AttributeDescriptor> mCachedHiddenAttributes; |
| /** An optional list of {@link IUiUpdateListener}. Most element nodes will not have any |
| * listeners attached, so the list is only created on demand and can be null. */ |
| private List<IUiUpdateListener> mUiUpdateListeners; |
| /** A provider that knows how to create {@link ElementDescriptor} from unmapped XML names. |
| * The default is to have one that creates new {@link ElementDescriptor}. */ |
| private IUnknownDescriptorProvider mUnknownDescProvider; |
| /** Error Flag */ |
| private boolean mHasError; |
| |
| /** |
| * Creates a new {@link UiElementNode} described by a given {@link ElementDescriptor}. |
| * |
| * @param elementDescriptor The {@link ElementDescriptor} for the XML node. Cannot be null. |
| */ |
| public UiElementNode(ElementDescriptor elementDescriptor) { |
| mDescriptor = elementDescriptor; |
| clearContent(); |
| } |
| |
| @Override |
| public String toString() { |
| return String.format("%s [desc: %s, parent: %s, children: %d]", //$NON-NLS-1$ |
| this.getClass().getSimpleName(), |
| mDescriptor, |
| mUiParent != null ? mUiParent.toString() : "none", //$NON-NLS-1$ |
| mUiChildren != null ? mUiChildren.size() : 0 |
| ); |
| } |
| |
| /** |
| * Clears the {@link UiElementNode} by resetting the children list and |
| * the {@link UiAttributeNode}s list. |
| * Also resets the attached XML node, document, editor if any. |
| * <p/> |
| * The parent {@link UiElementNode} node is not reset so that it's position |
| * in the hierarchy be left intact, if any. |
| */ |
| /* package */ void clearContent() { |
| mXmlNode = null; |
| mXmlDocument = null; |
| mEditor = null; |
| clearAttributes(); |
| mReadOnlyUiChildren = null; |
| if (mUiChildren == null) { |
| mUiChildren = new ArrayList<UiElementNode>(); |
| } else { |
| // We can't remove mandatory nodes, we just clear them. |
| for (int i = mUiChildren.size() - 1; i >= 0; --i) { |
| removeUiChildAtIndex(i); |
| } |
| } |
| } |
| |
| /** |
| * Clears the internal list of attributes, the read-only cached version of it |
| * and the read-only cached hidden attribute list. |
| */ |
| private void clearAttributes() { |
| mUiAttributes = null; |
| mCachedAllUiAttributes = null; |
| mCachedHiddenAttributes = null; |
| mUnknownUiAttributes = new HashSet<UiAttributeNode>(); |
| } |
| |
| /** |
| * Gets or creates the internal UiAttributes list. |
| * <p/> |
| * When the descriptor derives from ViewElementDescriptor, this list depends on the |
| * current UiParent node. |
| * |
| * @return A new set of {@link UiAttributeNode} that matches the expected |
| * attributes for this node. |
| */ |
| private HashMap<AttributeDescriptor, UiAttributeNode> getInternalUiAttributes() { |
| if (mUiAttributes == null) { |
| AttributeDescriptor[] attrList = getAttributeDescriptors(); |
| mUiAttributes = new HashMap<AttributeDescriptor, UiAttributeNode>(attrList.length); |
| for (AttributeDescriptor desc : attrList) { |
| UiAttributeNode uiNode = desc.createUiNode(this); |
| if (uiNode != null) { // Some AttributeDescriptors do not have UI associated |
| mUiAttributes.put(desc, uiNode); |
| } |
| } |
| } |
| return mUiAttributes; |
| } |
| |
| /** |
| * Computes a short string describing the UI node suitable for tree views. |
| * Uses the element's attribute "android:name" if present, or the "android:label" one |
| * followed by the element's name if not repeated. |
| * |
| * @return A short string describing the UI node suitable for tree views. |
| */ |
| public String getShortDescription() { |
| String name = mDescriptor.getUiName(); |
| String attr = getDescAttribute(); |
| if (attr != null) { |
| // If the ui name is repeated in the attribute value, don't use it. |
| // Typical case is to avoid ".pkg.MyActivity (Activity)". |
| if (attr.contains(name)) { |
| return attr; |
| } else { |
| return String.format("%1$s (%2$s)", attr, name); |
| } |
| } |
| |
| return name; |
| } |
| |
| /** Returns the key attribute that can be used to describe this node, or null */ |
| private String getDescAttribute() { |
| if (mXmlNode != null && mXmlNode instanceof Element && mXmlNode.hasAttributes()) { |
| // Application and Manifest nodes have a special treatment: they are unique nodes |
| // so we don't bother trying to differentiate their strings and we fall back to |
| // just using the UI name below. |
| Element elem = (Element) mXmlNode; |
| |
| String attr = _Element_getAttributeNS(elem, |
| SdkConstants.NS_RESOURCES, |
| AndroidManifestDescriptors.ANDROID_NAME_ATTR); |
| if (attr == null || attr.length() == 0) { |
| attr = _Element_getAttributeNS(elem, |
| SdkConstants.NS_RESOURCES, |
| AndroidManifestDescriptors.ANDROID_LABEL_ATTR); |
| } else if (mXmlNode.getNodeName().equals(SdkConstants.VIEW_FRAGMENT)) { |
| attr = attr.substring(attr.lastIndexOf('.') + 1); |
| } |
| if (attr == null || attr.length() == 0) { |
| attr = _Element_getAttributeNS(elem, |
| SdkConstants.NS_RESOURCES, |
| OtherXmlDescriptors.PREF_KEY_ATTR); |
| } |
| if (attr == null || attr.length() == 0) { |
| attr = _Element_getAttributeNS(elem, |
| null, // no namespace |
| SdkConstants.ATTR_NAME); |
| } |
| if (attr == null || attr.length() == 0) { |
| attr = _Element_getAttributeNS(elem, |
| SdkConstants.NS_RESOURCES, |
| SdkConstants.ATTR_ID); |
| |
| if (attr != null && attr.length() > 0) { |
| for (String prefix : ID_PREFIXES) { |
| if (attr.startsWith(prefix)) { |
| attr = attr.substring(prefix.length()); |
| break; |
| } |
| } |
| } |
| } |
| if (attr != null && attr.length() > 0) { |
| return attr; |
| } |
| } |
| |
| return null; |
| } |
| |
| /** |
| * Computes a styled string describing the UI node suitable for tree views. |
| * Similar to {@link #getShortDescription()} but styles the Strings. |
| * |
| * @return A styled string describing the UI node suitable for tree views. |
| */ |
| public StyledString getStyledDescription() { |
| String uiName = mDescriptor.getUiName(); |
| |
| // Special case: for <view>, show the class attribute value instead. |
| // This is done here rather than in the descriptor since this depends on |
| // node instance data. |
| if (SdkConstants.VIEW_TAG.equals(uiName) && mXmlNode instanceof Element) { |
| Element element = (Element) mXmlNode; |
| String cls = element.getAttribute(ATTR_CLASS); |
| if (cls != null) { |
| uiName = cls.substring(cls.lastIndexOf('.') + 1); |
| } |
| } |
| |
| StyledString styledString = new StyledString(); |
| String attr = getDescAttribute(); |
| if (attr != null) { |
| // Don't append the two when it's a repeat, e.g. Button01 (Button), |
| // only when the ui name is not part of the attribute |
| if (attr.toLowerCase(Locale.US).indexOf(uiName.toLowerCase(Locale.US)) == -1) { |
| styledString.append(attr); |
| styledString.append(String.format(" (%1$s)", uiName), |
| StyledString.DECORATIONS_STYLER); |
| } else { |
| styledString.append(attr); |
| } |
| } |
| |
| if (styledString.length() == 0) { |
| styledString.append(uiName); |
| } |
| |
| return styledString; |
| } |
| |
| /** |
| * Retrieves an attribute value by local name and namespace URI. |
| * <br>Per [<a href='http://www.w3.org/TR/1999/REC-xml-names-19990114/'>XML Namespaces</a>] |
| * , applications must use the value <code>null</code> as the |
| * <code>namespaceURI</code> parameter for methods if they wish to have |
| * no namespace. |
| * <p/> |
| * Note: This is a wrapper around {@link Element#getAttributeNS(String, String)}. |
| * In some versions of webtools, the getAttributeNS implementation crashes with an NPE. |
| * This wrapper will return an empty string instead. |
| * |
| * @see Element#getAttributeNS(String, String) |
| * @see <a href="https://bugs.eclipse.org/bugs/show_bug.cgi?id=318108">https://bugs.eclipse.org/bugs/show_bug.cgi?id=318108</a> |
| * @return The result from {@link Element#getAttributeNS(String, String)} or an empty string. |
| */ |
| private String _Element_getAttributeNS(Element element, |
| String namespaceURI, |
| String localName) { |
| try { |
| return element.getAttributeNS(namespaceURI, localName); |
| } catch (Exception ignore) { |
| return ""; |
| } |
| } |
| |
| /** |
| * Computes a "breadcrumb trail" description for this node. |
| * It will look something like "Manifest > Application > .myactivity (Activity) > Intent-Filter" |
| * |
| * @param includeRoot Whether to include the root (e.g. "Manifest") or not. Has no effect |
| * when called on the root node itself. |
| * @return The "breadcrumb trail" description for this node. |
| */ |
| public String getBreadcrumbTrailDescription(boolean includeRoot) { |
| StringBuilder sb = new StringBuilder(getShortDescription()); |
| |
| for (UiElementNode uiNode = getUiParent(); |
| uiNode != null; |
| uiNode = uiNode.getUiParent()) { |
| if (!includeRoot && uiNode.getUiParent() == null) { |
| break; |
| } |
| sb.insert(0, String.format("%1$s > ", uiNode.getShortDescription())); //$NON-NLS-1$ |
| } |
| |
| return sb.toString(); |
| } |
| |
| /** |
| * Sets the XML {@link Document}. |
| * <p/> |
| * The XML {@link Document} is initially null. The XML {@link Document} must be set only on the |
| * UI root element node (this method takes care of that.) |
| * @param xmlDoc The new XML document to associate this node with. |
| */ |
| public void setXmlDocument(Document xmlDoc) { |
| if (mUiParent == null) { |
| mXmlDocument = xmlDoc; |
| } else { |
| mUiParent.setXmlDocument(xmlDoc); |
| } |
| } |
| |
| /** |
| * Returns the XML {@link Document}. |
| * <p/> |
| * The value is initially null until the UI node is attached to its UI parent -- the value |
| * of the document is then propagated. |
| * |
| * @return the XML {@link Document} or the parent's XML {@link Document} or null. |
| */ |
| public Document getXmlDocument() { |
| if (mXmlDocument != null) { |
| return mXmlDocument; |
| } else if (mUiParent != null) { |
| return mUiParent.getXmlDocument(); |
| } |
| return null; |
| } |
| |
| /** |
| * Returns the XML node associated with this UI node. |
| * <p/> |
| * Some {@link ElementDescriptor} are declared as being "mandatory". This means the |
| * corresponding UI node will exist even if there is no corresponding XML node. Such structure |
| * is created and enforced by the parent of the tree, not the element themselves. However |
| * such nodes will likely not have an XML node associated, so getXmlNode() can return null. |
| * |
| * @return The associated XML node. Can be null for mandatory nodes. |
| */ |
| public Node getXmlNode() { |
| return mXmlNode; |
| } |
| |
| /** |
| * Returns the {@link ElementDescriptor} for this node. This is never null. |
| * <p/> |
| * Do not use this to call getDescriptor().getAttributes(), instead call |
| * getAttributeDescriptors() which can be overridden by derived classes. |
| * @return The {@link ElementDescriptor} for this node. This is never null. |
| */ |
| public ElementDescriptor getDescriptor() { |
| return mDescriptor; |
| } |
| |
| /** |
| * Returns the {@link AttributeDescriptor} array for the descriptor of this node. |
| * <p/> |
| * Use this instead of getDescriptor().getAttributes() -- derived classes can override |
| * this to manipulate the attribute descriptor list depending on the current UI node. |
| * @return The {@link AttributeDescriptor} array for the descriptor of this node. |
| */ |
| public AttributeDescriptor[] getAttributeDescriptors() { |
| return mDescriptor.getAttributes(); |
| } |
| |
| /** |
| * Returns the hidden {@link AttributeDescriptor} array for the descriptor of this node. |
| * This is a subset of the getAttributeDescriptors() list. |
| * <p/> |
| * Use this instead of getDescriptor().getHiddenAttributes() -- potentially derived classes |
| * could override this to manipulate the attribute descriptor list depending on the current |
| * UI node. There's no need for it right now so keep it private. |
| */ |
| private Map<String, AttributeDescriptor> getHiddenAttributeDescriptors() { |
| if (mCachedHiddenAttributes == null) { |
| mCachedHiddenAttributes = new HashMap<String, AttributeDescriptor>(); |
| for (AttributeDescriptor attrDesc : getAttributeDescriptors()) { |
| if (attrDesc instanceof XmlnsAttributeDescriptor) { |
| mCachedHiddenAttributes.put( |
| ((XmlnsAttributeDescriptor) attrDesc).getXmlNsName(), |
| attrDesc); |
| } |
| } |
| } |
| return mCachedHiddenAttributes; |
| } |
| |
| /** |
| * Sets the parent of this UiElementNode. |
| * <p/> |
| * The root node has no parent. |
| */ |
| protected void setUiParent(UiElementNode parent) { |
| mUiParent = parent; |
| // Invalidate the internal UiAttributes list, as it may depend on the actual UiParent. |
| clearAttributes(); |
| } |
| |
| /** |
| * @return The parent {@link UiElementNode} or null if this is the root node. |
| */ |
| public UiElementNode getUiParent() { |
| return mUiParent; |
| } |
| |
| /** |
| * Returns the root {@link UiElementNode}. |
| * |
| * @return The root {@link UiElementNode}. |
| */ |
| public UiElementNode getUiRoot() { |
| UiElementNode root = this; |
| while (root.mUiParent != null) { |
| root = root.mUiParent; |
| } |
| |
| return root; |
| } |
| |
| /** |
| * Returns the index of this sibling (where the first child has index 0, the second child |
| * has index 1, and so on.) |
| * |
| * @return The sibling index of this node |
| */ |
| public int getUiSiblingIndex() { |
| if (mUiParent != null) { |
| int index = 0; |
| for (UiElementNode node : mUiParent.getUiChildren()) { |
| if (node == this) { |
| break; |
| } |
| index++; |
| } |
| return index; |
| } |
| |
| return 0; |
| } |
| |
| /** |
| * Returns the previous UI sibling of this UI node. If the node does not have a previous |
| * sibling, returns null. |
| * |
| * @return The previous UI sibling of this UI node, or null if not applicable. |
| */ |
| public UiElementNode getUiPreviousSibling() { |
| if (mUiParent != null) { |
| List<UiElementNode> childlist = mUiParent.getUiChildren(); |
| if (childlist != null && childlist.size() > 1 && childlist.get(0) != this) { |
| int index = childlist.indexOf(this); |
| return index > 0 ? childlist.get(index - 1) : null; |
| } |
| } |
| return null; |
| } |
| |
| /** |
| * Returns the next UI sibling of this UI node. |
| * If the node does not have a next sibling, returns null. |
| * |
| * @return The next UI sibling of this UI node, or null. |
| */ |
| public UiElementNode getUiNextSibling() { |
| if (mUiParent != null) { |
| List<UiElementNode> childlist = mUiParent.getUiChildren(); |
| if (childlist != null) { |
| int size = childlist.size(); |
| if (size > 1 && childlist.get(size - 1) != this) { |
| int index = childlist.indexOf(this); |
| return index >= 0 && index < size - 1 ? childlist.get(index + 1) : null; |
| } |
| } |
| } |
| return null; |
| } |
| |
| /** |
| * Sets the {@link AndroidXmlEditor} handling this {@link UiElementNode} hierarchy. |
| * <p/> |
| * The editor must always be set on the root node. This method takes care of that. |
| * |
| * @param editor The editor to associate this node with. |
| */ |
| public void setEditor(AndroidXmlEditor editor) { |
| if (mUiParent == null) { |
| mEditor = editor; |
| } else { |
| mUiParent.setEditor(editor); |
| } |
| } |
| |
| /** |
| * Returns the {@link AndroidXmlEditor} that embeds this {@link UiElementNode}. |
| * <p/> |
| * The value is initially null until the node is attached to its parent -- the value |
| * of the root node is then propagated. |
| * |
| * @return The embedding {@link AndroidXmlEditor} or null. |
| */ |
| public AndroidXmlEditor getEditor() { |
| return mUiParent == null ? mEditor : mUiParent.getEditor(); |
| } |
| |
| /** |
| * Returns the Android target data for the file being edited. |
| * |
| * @return The Android target data for the file being edited. |
| */ |
| public AndroidTargetData getAndroidTarget() { |
| return getEditor().getTargetData(); |
| } |
| |
| /** |
| * @return A read-only version of the children collection. |
| */ |
| public List<UiElementNode> getUiChildren() { |
| if (mReadOnlyUiChildren == null) { |
| mReadOnlyUiChildren = Collections.unmodifiableList(mUiChildren); |
| } |
| return mReadOnlyUiChildren; |
| } |
| |
| /** |
| * Returns a collection containing all the known attributes as well as |
| * all the unknown ui attributes. |
| * |
| * @return A read-only version of the attributes collection. |
| */ |
| public Collection<UiAttributeNode> getAllUiAttributes() { |
| if (mCachedAllUiAttributes == null) { |
| |
| List<UiAttributeNode> allValues = |
| new ArrayList<UiAttributeNode>(getInternalUiAttributes().values()); |
| allValues.addAll(mUnknownUiAttributes); |
| |
| mCachedAllUiAttributes = Collections.unmodifiableCollection(allValues); |
| } |
| return mCachedAllUiAttributes; |
| } |
| |
| /** |
| * Returns all the unknown ui attributes, that is those we found defined in the |
| * actual XML but that we don't have descriptors for. |
| * |
| * @return A read-only version of the unknown attributes collection. |
| */ |
| public Collection<UiAttributeNode> getUnknownUiAttributes() { |
| return Collections.unmodifiableCollection(mUnknownUiAttributes); |
| } |
| |
| /** |
| * Sets the error flag value. |
| * |
| * @param errorFlag the error flag |
| */ |
| public final void setHasError(boolean errorFlag) { |
| mHasError = errorFlag; |
| } |
| |
| /** |
| * Returns whether this node, its attributes, or one of the children nodes (and attributes) |
| * has errors. |
| * |
| * @return True if this node, its attributes, or one of the children nodes (and attributes) |
| * has errors. |
| */ |
| public final boolean hasError() { |
| if (mHasError) { |
| return true; |
| } |
| |
| // get the error value from the attributes. |
| for (UiAttributeNode attribute : getAllUiAttributes()) { |
| if (attribute.hasError()) { |
| return true; |
| } |
| } |
| |
| // and now from the children. |
| for (UiElementNode child : mUiChildren) { |
| if (child.hasError()) { |
| return true; |
| } |
| } |
| |
| return false; |
| } |
| |
| /** |
| * Returns the provider that knows how to create {@link ElementDescriptor} from unmapped |
| * XML names. |
| * <p/> |
| * The default is to have one that creates new {@link ElementDescriptor}. |
| * <p/> |
| * There is only one such provider in any UI model tree, attached to the root node. |
| * |
| * @return An instance of {@link IUnknownDescriptorProvider}. Can never be null. |
| */ |
| public IUnknownDescriptorProvider getUnknownDescriptorProvider() { |
| if (mUiParent != null) { |
| return mUiParent.getUnknownDescriptorProvider(); |
| } |
| if (mUnknownDescProvider == null) { |
| // Create the default one on demand. |
| mUnknownDescProvider = new IUnknownDescriptorProvider() { |
| |
| private final HashMap<String, ElementDescriptor> mMap = |
| new HashMap<String, ElementDescriptor>(); |
| |
| /** |
| * The default is to create a new ElementDescriptor wrapping |
| * the unknown XML local name and reuse previously created descriptors. |
| */ |
| @Override |
| public ElementDescriptor getDescriptor(String xmlLocalName) { |
| |
| ElementDescriptor desc = mMap.get(xmlLocalName); |
| |
| if (desc == null) { |
| desc = new ElementDescriptor(xmlLocalName); |
| mMap.put(xmlLocalName, desc); |
| } |
| |
| return desc; |
| } |
| }; |
| } |
| return mUnknownDescProvider; |
| } |
| |
| /** |
| * Sets the provider that knows how to create {@link ElementDescriptor} from unmapped |
| * XML names. |
| * <p/> |
| * The default is to have one that creates new {@link ElementDescriptor}. |
| * <p/> |
| * There is only one such provider in any UI model tree, attached to the root node. |
| * |
| * @param unknownDescProvider The new provider to use. Must not be null. |
| */ |
| public void setUnknownDescriptorProvider(IUnknownDescriptorProvider unknownDescProvider) { |
| if (mUiParent == null) { |
| mUnknownDescProvider = unknownDescProvider; |
| } else { |
| mUiParent.setUnknownDescriptorProvider(unknownDescProvider); |
| } |
| } |
| |
| /** |
| * Adds a new {@link IUiUpdateListener} to the internal update listener list. |
| * |
| * @param listener The listener to add. |
| */ |
| public void addUpdateListener(IUiUpdateListener listener) { |
| if (mUiUpdateListeners == null) { |
| mUiUpdateListeners = new ArrayList<IUiUpdateListener>(); |
| } |
| if (!mUiUpdateListeners.contains(listener)) { |
| mUiUpdateListeners.add(listener); |
| } |
| } |
| |
| /** |
| * Removes an existing {@link IUiUpdateListener} from the internal update listener list. |
| * Does nothing if the list is empty or the listener is not registered. |
| * |
| * @param listener The listener to remove. |
| */ |
| public void removeUpdateListener(IUiUpdateListener listener) { |
| if (mUiUpdateListeners != null) { |
| mUiUpdateListeners.remove(listener); |
| } |
| } |
| |
| /** |
| * Finds a child node relative to this node using a path-like expression. |
| * F.ex. "node1/node2" would find a child "node1" that contains a child "node2" and |
| * returns the latter. If there are multiple nodes with the same name at the same |
| * level, always uses the first one found. |
| * |
| * @param path The path like expression to select a child node. |
| * @return The ui node found or null. |
| */ |
| public UiElementNode findUiChildNode(String path) { |
| String[] items = path.split("/"); //$NON-NLS-1$ |
| UiElementNode uiNode = this; |
| for (String item : items) { |
| boolean nextSegment = false; |
| for (UiElementNode c : uiNode.mUiChildren) { |
| if (c.getDescriptor().getXmlName().equals(item)) { |
| uiNode = c; |
| nextSegment = true; |
| break; |
| } |
| } |
| if (!nextSegment) { |
| return null; |
| } |
| } |
| return uiNode; |
| } |
| |
| /** |
| * Finds an {@link UiElementNode} which contains the give XML {@link Node}. |
| * Looks recursively in all children UI nodes. |
| * |
| * @param xmlNode The XML node to look for. |
| * @return The {@link UiElementNode} that contains xmlNode or null if not found, |
| */ |
| public UiElementNode findXmlNode(Node xmlNode) { |
| if (xmlNode == null) { |
| return null; |
| } |
| if (getXmlNode() == xmlNode) { |
| return this; |
| } |
| |
| for (UiElementNode uiChild : mUiChildren) { |
| UiElementNode found = uiChild.findXmlNode(xmlNode); |
| if (found != null) { |
| return found; |
| } |
| } |
| |
| return null; |
| } |
| |
| /** |
| * Returns the {@link UiAttributeNode} matching this attribute descriptor or |
| * null if not found. |
| * |
| * @param attrDesc The {@link AttributeDescriptor} to match. |
| * @return the {@link UiAttributeNode} matching this attribute descriptor or null |
| * if not found. |
| */ |
| public UiAttributeNode findUiAttribute(AttributeDescriptor attrDesc) { |
| return getInternalUiAttributes().get(attrDesc); |
| } |
| |
| /** |
| * Populate this element node with all values from the given XML node. |
| * |
| * This fails if the given XML node has a different element name -- it won't change the |
| * type of this ui node. |
| * |
| * This method can be both used for populating values the first time and updating values |
| * after the XML model changed. |
| * |
| * @param xmlNode The XML node to mirror |
| * @return Returns true if the XML structure has changed (nodes added, removed or replaced) |
| */ |
| public boolean loadFromXmlNode(Node xmlNode) { |
| boolean structureChanged = (mXmlNode != xmlNode); |
| mXmlNode = xmlNode; |
| if (xmlNode != null) { |
| updateAttributeList(xmlNode); |
| structureChanged |= updateElementList(xmlNode); |
| invokeUiUpdateListeners(structureChanged ? UiUpdateState.CHILDREN_CHANGED |
| : UiUpdateState.ATTR_UPDATED); |
| } |
| return structureChanged; |
| } |
| |
| /** |
| * Clears the UI node and reload it from the given XML node. |
| * <p/> |
| * This works by clearing all references to any previous XML or UI nodes and |
| * then reloads the XML document from scratch. The editor reference is kept. |
| * <p/> |
| * This is used in the special case where the ElementDescriptor structure has changed. |
| * Rather than try to diff inflated UI nodes (as loadFromXmlNode does), we don't bother |
| * and reload everything. This is not subtle and should be used very rarely. |
| * |
| * @param xmlNode The XML node or document to reload. Can be null. |
| */ |
| public void reloadFromXmlNode(Node xmlNode) { |
| // The editor needs to be preserved, it is not affected by an XML change. |
| AndroidXmlEditor editor = getEditor(); |
| clearContent(); |
| setEditor(editor); |
| if (xmlNode != null) { |
| setXmlDocument(xmlNode.getOwnerDocument()); |
| } |
| // This will reload all the XML and recreate the UI structure from scratch. |
| loadFromXmlNode(xmlNode); |
| } |
| |
| /** |
| * Called by attributes when they want to commit their value |
| * to an XML node. |
| * <p/> |
| * For mandatory nodes, this makes sure the underlying XML element node |
| * exists in the model. If not, it is created and assigned as the underlying |
| * XML node. |
| * </br> |
| * For non-mandatory nodes, simply return the underlying XML node, which |
| * must always exists. |
| * |
| * @return The XML node matching this {@link UiElementNode} or null. |
| */ |
| public Node prepareCommit() { |
| if (getDescriptor().getMandatory() != Mandatory.NOT_MANDATORY) { |
| createXmlNode(); |
| // The new XML node has been created. |
| // We don't need to refresh using loadFromXmlNode() since there are |
| // no attributes or elements that need to be loading into this node. |
| } |
| return getXmlNode(); |
| } |
| |
| /** |
| * Commits the attributes (all internal, inherited from UI parent & unknown attributes). |
| * This is called by the UI when the embedding part needs to be committed. |
| */ |
| public void commit() { |
| for (UiAttributeNode uiAttr : getAllUiAttributes()) { |
| uiAttr.commit(); |
| } |
| } |
| |
| /** |
| * Returns true if the part has been modified with respect to the data |
| * loaded from the model. |
| * @return True if the part has been modified with respect to the data |
| * loaded from the model. |
| */ |
| public boolean isDirty() { |
| for (UiAttributeNode uiAttr : getAllUiAttributes()) { |
| if (uiAttr.isDirty()) { |
| return true; |
| } |
| } |
| |
| return false; |
| } |
| |
| /** |
| * Creates the underlying XML element node for this UI node if it doesn't already |
| * exists. |
| * |
| * @return The new value of getXmlNode() (can be null if creation failed) |
| */ |
| public Node createXmlNode() { |
| if (mXmlNode != null) { |
| return null; |
| } |
| Node parentXmlNode = null; |
| if (mUiParent != null) { |
| parentXmlNode = mUiParent.prepareCommit(); |
| if (parentXmlNode == null) { |
| // The parent failed to create its own backing XML node. Abort. |
| // No need to throw an exception, the parent will most likely |
| // have done so itself. |
| return null; |
| } |
| } |
| |
| String elementName = getDescriptor().getXmlName(); |
| Document doc = getXmlDocument(); |
| |
| // We *must* have a root node. If not, we need to abort. |
| if (doc == null) { |
| throw new RuntimeException( |
| String.format("Missing XML document for %1$s XML node.", elementName)); |
| } |
| |
| // If we get here and parentXmlNode is null, the node is to be created |
| // as the root node of the document (which can't be null, cf. check above). |
| if (parentXmlNode == null) { |
| parentXmlNode = doc; |
| } |
| |
| mXmlNode = doc.createElement(elementName); |
| |
| // If this element does not have children, mark it as an empty tag |
| // such that the XML looks like <tag/> instead of <tag></tag> |
| if (!mDescriptor.hasChildren()) { |
| if (mXmlNode instanceof ElementImpl) { |
| ElementImpl element = (ElementImpl) mXmlNode; |
| element.setEmptyTag(true); |
| } |
| } |
| |
| Node xmlNextSibling = null; |
| |
| UiElementNode uiNextSibling = getUiNextSibling(); |
| if (uiNextSibling != null) { |
| xmlNextSibling = uiNextSibling.getXmlNode(); |
| } |
| |
| Node previousTextNode = null; |
| if (xmlNextSibling != null) { |
| Node previousNode = xmlNextSibling.getPreviousSibling(); |
| if (previousNode != null && previousNode.getNodeType() == Node.TEXT_NODE) { |
| previousTextNode = previousNode; |
| } |
| } else { |
| Node lastChild = parentXmlNode.getLastChild(); |
| if (lastChild != null && lastChild.getNodeType() == Node.TEXT_NODE) { |
| previousTextNode = lastChild; |
| } |
| } |
| |
| String insertAfter = null; |
| |
| // Try to figure out the indentation node to insert. Even in auto-formatting |
| // we need to do this, because it turns out the XML editor's formatter does |
| // not do a very good job with completely botched up XML; it does a much better |
| // job if the new XML is already mostly well formatted. Thus, the main purpose |
| // of applying the real XML formatter after our own indentation attempts here is |
| // to make it apply its own tab-versus-spaces indentation properties, have it |
| // insert line breaks before attributes (if the user has configured that), etc. |
| |
| // First figure out the indentation level of the newly inserted element; |
| // this is either the same as the previous sibling, or if there is no sibling, |
| // it's the indentation of the parent plus one indentation level. |
| boolean isFirstChild = getUiPreviousSibling() == null |
| || parentXmlNode.getFirstChild() == null; |
| AndroidXmlEditor editor = getEditor(); |
| String indent; |
| String parentIndent = ""; //$NON-NLS-1$ |
| if (isFirstChild) { |
| indent = parentIndent = editor.getIndent(parentXmlNode); |
| // We need to add one level of indentation. Are we using tabs? |
| // Can't get to formatting settings so let's just look at the |
| // parent indentation and see if we can guess |
| if (indent.length() > 0 && indent.charAt(indent.length()-1) == '\t') { |
| indent = indent + '\t'; |
| } else { |
| // Not using tabs, or we can't figure it out (because parent had no |
| // indentation). In that case, indent with 4 spaces, as seems to |
| // be the Android default. |
| indent = indent + " "; //$NON-NLS-1$ |
| } |
| } else { |
| // Find out the indent of the previous sibling |
| indent = editor.getIndent(getUiPreviousSibling().getXmlNode()); |
| } |
| |
| // We want to insert the new element BEFORE the text node which precedes |
| // the next element, since that text node is the next element's indentation! |
| if (previousTextNode != null) { |
| xmlNextSibling = previousTextNode; |
| } else { |
| // If there's no previous text node, we are probably inside an |
| // empty element (<LinearLayout>|</LinearLayout>) and in that case we need |
| // to not only insert a newline and indentation before the new element, but |
| // after it as well. |
| insertAfter = parentIndent; |
| } |
| |
| // Insert indent text node before the new element |
| IStructuredDocument document = editor.getStructuredDocument(); |
| String newLine; |
| if (document != null) { |
| newLine = TextUtilities.getDefaultLineDelimiter(document); |
| } else { |
| newLine = SdkUtils.getLineSeparator(); |
| } |
| Text indentNode = doc.createTextNode(newLine + indent); |
| parentXmlNode.insertBefore(indentNode, xmlNextSibling); |
| |
| // Insert the element itself |
| parentXmlNode.insertBefore(mXmlNode, xmlNextSibling); |
| |
| // Insert a separator after the tag. We only do this when we've inserted |
| // a tag into an area where there was no whitespace before |
| // (e.g. a new child of <LinearLayout></LinearLayout>). |
| if (insertAfter != null) { |
| Text sep = doc.createTextNode(newLine + insertAfter); |
| parentXmlNode.insertBefore(sep, xmlNextSibling); |
| } |
| |
| // Set all initial attributes in the XML node if they are not empty. |
| // Iterate on the descriptor list to get the desired order and then use the |
| // internal values, if any. |
| List<UiAttributeNode> addAttributes = new ArrayList<UiAttributeNode>(); |
| |
| for (AttributeDescriptor attrDesc : getAttributeDescriptors()) { |
| if (attrDesc instanceof XmlnsAttributeDescriptor) { |
| XmlnsAttributeDescriptor desc = (XmlnsAttributeDescriptor) attrDesc; |
| Attr attr = doc.createAttributeNS(SdkConstants.XMLNS_URI, |
| desc.getXmlNsName()); |
| attr.setValue(desc.getValue()); |
| attr.setPrefix(desc.getXmlNsPrefix()); |
| mXmlNode.getAttributes().setNamedItemNS(attr); |
| } else { |
| UiAttributeNode uiAttr = getInternalUiAttributes().get(attrDesc); |
| |
| // Don't apply the attribute immediately, instead record this attribute |
| // such that we can gather all attributes and sort them first. |
| // This is necessary because the XML model will *append* all attributes |
| // so we want to add them in a particular order. |
| // (Note that we only have to worry about UiAttributeNodes with non null |
| // values, since this is a new node and we therefore don't need to attempt |
| // to remove existing attributes) |
| String value = uiAttr.getCurrentValue(); |
| if (value != null && value.length() > 0) { |
| addAttributes.add(uiAttr); |
| } |
| } |
| } |
| |
| // Sort and apply the attributes in order, because the Eclipse XML model will always |
| // append the XML attributes, so by inserting them in our desired order they will |
| // appear that way in the XML |
| Collections.sort(addAttributes); |
| |
| for (UiAttributeNode node : addAttributes) { |
| commitAttributeToXml(node, node.getCurrentValue()); |
| node.setDirty(false); |
| } |
| |
| getEditor().scheduleNodeReformat(this, false); |
| |
| // Notify per-node listeners |
| invokeUiUpdateListeners(UiUpdateState.CREATED); |
| // Notify global listeners |
| fireNodeCreated(this, getUiSiblingIndex()); |
| |
| return mXmlNode; |
| } |
| |
| /** |
| * Removes the XML node corresponding to this UI node if it exists |
| * and also removes all mirrored information in this UI node (i.e. children, attributes) |
| * |
| * @return The removed node or null if it didn't exist in the first place. |
| */ |
| public Node deleteXmlNode() { |
| if (mXmlNode == null) { |
| return null; |
| } |
| |
| int previousIndex = getUiSiblingIndex(); |
| |
| // First clear the internals of the node and *then* actually deletes the XML |
| // node (because doing so will generate an update even and this node may be |
| // revisited via loadFromXmlNode). |
| Node oldXmlNode = mXmlNode; |
| clearContent(); |
| |
| Node xmlParent = oldXmlNode.getParentNode(); |
| if (xmlParent == null) { |
| xmlParent = getXmlDocument(); |
| } |
| Node previousSibling = oldXmlNode.getPreviousSibling(); |
| oldXmlNode = xmlParent.removeChild(oldXmlNode); |
| |
| // We need to remove the text node BEFORE the removed element, since THAT's the |
| // indentation node for the removed element. |
| if (previousSibling != null && previousSibling.getNodeType() == Node.TEXT_NODE |
| && previousSibling.getNodeValue().trim().length() == 0) { |
| xmlParent.removeChild(previousSibling); |
| } |
| |
| invokeUiUpdateListeners(UiUpdateState.DELETED); |
| fireNodeDeleted(this, previousIndex); |
| |
| return oldXmlNode; |
| } |
| |
| /** |
| * Updates the element list for this UiElementNode. |
| * At the end, the list of children UiElementNode here will match the one from the |
| * provided XML {@link Node}: |
| * <ul> |
| * <li> Walk both the current ui children list and the xml children list at the same time. |
| * <li> If we have a new xml child but already reached the end of the ui child list, add the |
| * new xml node. |
| * <li> Otherwise, check if the xml node is referenced later in the ui child list and if so, |
| * move it here. It means the XML child list has been reordered. |
| * <li> Otherwise, this is a new XML node that we add in the middle of the ui child list. |
| * <li> At the end, we may have finished walking the xml child list but still have remaining |
| * ui children, simply delete them as they matching trailing xml nodes that have been |
| * removed unless they are mandatory ui nodes. |
| * </ul> |
| * Note that only the first case is used when populating the ui list the first time. |
| * |
| * @param xmlNode The XML node to mirror |
| * @return True when the XML structure has changed. |
| */ |
| protected boolean updateElementList(Node xmlNode) { |
| boolean structureChanged = false; |
| boolean hasMandatoryLast = false; |
| int uiIndex = 0; |
| Node xmlChild = xmlNode.getFirstChild(); |
| while (xmlChild != null) { |
| if (xmlChild.getNodeType() == Node.ELEMENT_NODE) { |
| String elementName = xmlChild.getNodeName(); |
| UiElementNode uiNode = null; |
| CustomViewDescriptorService service = CustomViewDescriptorService.getInstance(); |
| if (mUiChildren.size() <= uiIndex) { |
| // A new node is being added at the end of the list |
| ElementDescriptor desc = mDescriptor.findChildrenDescriptor(elementName, |
| false /* recursive */); |
| if (desc == null && elementName.indexOf('.') != -1 && |
| (!elementName.startsWith(ANDROID_PKG_PREFIX) |
| || elementName.startsWith(ANDROID_SUPPORT_PKG_PREFIX))) { |
| AndroidXmlEditor editor = getEditor(); |
| if (editor != null && editor.getProject() != null) { |
| desc = service.getDescriptor(editor.getProject(), elementName); |
| } |
| } |
| if (desc == null) { |
| // Unknown node. Create a temporary descriptor for it. |
| // We'll add unknown attributes to it later. |
| IUnknownDescriptorProvider p = getUnknownDescriptorProvider(); |
| desc = p.getDescriptor(elementName); |
| } |
| structureChanged = true; |
| uiNode = appendNewUiChild(desc); |
| uiIndex++; |
| } else { |
| // A new node is being inserted or moved. |
| // Note: mandatory nodes can be created without an XML node in which case |
| // getXmlNode() is null. |
| UiElementNode uiChild; |
| int n = mUiChildren.size(); |
| for (int j = uiIndex; j < n; j++) { |
| uiChild = mUiChildren.get(j); |
| if (uiChild.getXmlNode() != null && uiChild.getXmlNode() == xmlChild) { |
| if (j > uiIndex) { |
| // Found the same XML node at some later index, now move it here. |
| mUiChildren.remove(j); |
| mUiChildren.add(uiIndex, uiChild); |
| structureChanged = true; |
| } |
| uiNode = uiChild; |
| uiIndex++; |
| break; |
| } |
| } |
| |
| if (uiNode == null) { |
| // Look for an unused mandatory node with no XML node attached |
| // referencing the same XML element name |
| for (int j = uiIndex; j < n; j++) { |
| uiChild = mUiChildren.get(j); |
| if (uiChild.getXmlNode() == null && |
| uiChild.getDescriptor().getMandatory() != |
| Mandatory.NOT_MANDATORY && |
| uiChild.getDescriptor().getXmlName().equals(elementName)) { |
| |
| if (j > uiIndex) { |
| // Found it, now move it here |
| mUiChildren.remove(j); |
| mUiChildren.add(uiIndex, uiChild); |
| } |
| // Assign the XML node to this empty mandatory element. |
| uiChild.mXmlNode = xmlChild; |
| structureChanged = true; |
| uiNode = uiChild; |
| uiIndex++; |
| } |
| } |
| } |
| |
| if (uiNode == null) { |
| // Inserting new node |
| ElementDescriptor desc = mDescriptor.findChildrenDescriptor(elementName, |
| false /* recursive */); |
| if (desc == null && elementName.indexOf('.') != -1 && |
| (!elementName.startsWith(ANDROID_PKG_PREFIX) |
| || elementName.startsWith(ANDROID_SUPPORT_PKG_PREFIX))) { |
| AndroidXmlEditor editor = getEditor(); |
| if (editor != null && editor.getProject() != null) { |
| desc = service.getDescriptor(editor.getProject(), elementName); |
| } |
| } |
| if (desc == null) { |
| // Unknown node. Create a temporary descriptor for it. |
| // We'll add unknown attributes to it later. |
| IUnknownDescriptorProvider p = getUnknownDescriptorProvider(); |
| desc = p.getDescriptor(elementName); |
| } else { |
| structureChanged = true; |
| uiNode = insertNewUiChild(uiIndex, desc); |
| uiIndex++; |
| } |
| } |
| } |
| if (uiNode != null) { |
| // If we touched an UI Node, even an existing one, refresh its content. |
| // For new nodes, this will populate them recursively. |
| structureChanged |= uiNode.loadFromXmlNode(xmlChild); |
| |
| // Remember if there are any mandatory-last nodes to reorder. |
| hasMandatoryLast |= |
| uiNode.getDescriptor().getMandatory() == Mandatory.MANDATORY_LAST; |
| } |
| } |
| xmlChild = xmlChild.getNextSibling(); |
| } |
| |
| // There might be extra UI nodes at the end if the XML node list got shorter. |
| for (int index = mUiChildren.size() - 1; index >= uiIndex; --index) { |
| structureChanged |= removeUiChildAtIndex(index); |
| } |
| |
| if (hasMandatoryLast) { |
| // At least one mandatory-last uiNode was moved. Let's see if we can |
| // move them back to the last position. That's possible if the only |
| // thing between these and the end are other mandatory empty uiNodes |
| // (mandatory uiNodes with no XML attached are pure "virtual" reserved |
| // slots and it's ok to reorganize them but other can't.) |
| int n = mUiChildren.size() - 1; |
| for (int index = n; index >= 0; index--) { |
| UiElementNode uiChild = mUiChildren.get(index); |
| Mandatory mand = uiChild.getDescriptor().getMandatory(); |
| if (mand == Mandatory.MANDATORY_LAST && index < n) { |
| // Remove it from index and move it back at the end of the list. |
| mUiChildren.remove(index); |
| mUiChildren.add(uiChild); |
| } else if (mand == Mandatory.NOT_MANDATORY || uiChild.getXmlNode() != null) { |
| // We found at least one non-mandatory or a mandatory node with an actual |
| // XML attached, so there's nothing we can reorganize past this point. |
| break; |
| } |
| } |
| } |
| |
| return structureChanged; |
| } |
| |
| /** |
| * Internal helper to remove an UI child node given by its index in the |
| * internal child list. |
| * |
| * Also invokes the update listener on the node to be deleted *after* the node has |
| * been removed. |
| * |
| * @param uiIndex The index of the UI child to remove, range 0 .. mUiChildren.size()-1 |
| * @return True if the structure has changed |
| * @throws IndexOutOfBoundsException if index is out of mUiChildren's bounds. Of course you |
| * know that could never happen unless the computer is on fire or something. |
| */ |
| private boolean removeUiChildAtIndex(int uiIndex) { |
| UiElementNode uiNode = mUiChildren.get(uiIndex); |
| ElementDescriptor desc = uiNode.getDescriptor(); |
| |
| try { |
| if (uiNode.getDescriptor().getMandatory() != Mandatory.NOT_MANDATORY) { |
| // This is a mandatory node. Such a node must exist in the UiNode hierarchy |
| // even if there's no XML counterpart. However we only need to keep one. |
| |
| // Check if the parent (e.g. this node) has another similar ui child node. |
| boolean keepNode = true; |
| for (UiElementNode child : mUiChildren) { |
| if (child != uiNode && child.getDescriptor() == desc) { |
| // We found another child with the same descriptor that is not |
| // the node we want to remove. This means we have one mandatory |
| // node so we can safely remove uiNode. |
| keepNode = false; |
| break; |
| } |
| } |
| |
| if (keepNode) { |
| // We can't remove a mandatory node as we need to keep at least one |
| // mandatory node in the parent. Instead we just clear its content |
| // (including its XML Node reference). |
| |
| // A mandatory node with no XML means it doesn't really exist, so it can't be |
| // deleted. So the structure will change only if the ui node is actually |
| // associated to an XML node. |
| boolean xmlExists = (uiNode.getXmlNode() != null); |
| |
| uiNode.clearContent(); |
| return xmlExists; |
| } |
| } |
| |
| mUiChildren.remove(uiIndex); |
| |
| return true; |
| } finally { |
| // Tell listeners that a node has been removed. |
| // The model has already been modified. |
| invokeUiUpdateListeners(UiUpdateState.DELETED); |
| } |
| } |
| |
| /** |
| * Creates a new {@link UiElementNode} from the given {@link ElementDescriptor} |
| * and appends it to the end of the element children list. |
| * |
| * @param descriptor The {@link ElementDescriptor} that knows how to create the UI node. |
| * @return The new UI node that has been appended |
| */ |
| public UiElementNode appendNewUiChild(ElementDescriptor descriptor) { |
| UiElementNode uiNode; |
| uiNode = descriptor.createUiNode(); |
| mUiChildren.add(uiNode); |
| uiNode.setUiParent(this); |
| uiNode.invokeUiUpdateListeners(UiUpdateState.CREATED); |
| return uiNode; |
| } |
| |
| /** |
| * Creates a new {@link UiElementNode} from the given {@link ElementDescriptor} |
| * and inserts it in the element children list at the specified position. |
| * |
| * @param index The position where to insert in the element children list. |
| * Shifts the element currently at that position (if any) and any |
| * subsequent elements to the right (adds one to their indices). |
| * Index must >= 0 and <= getUiChildren.size(). |
| * Using size() means to append to the end of the list. |
| * @param descriptor The {@link ElementDescriptor} that knows how to create the UI node. |
| * @return The new UI node. |
| */ |
| public UiElementNode insertNewUiChild(int index, ElementDescriptor descriptor) { |
| UiElementNode uiNode; |
| uiNode = descriptor.createUiNode(); |
| mUiChildren.add(index, uiNode); |
| uiNode.setUiParent(this); |
| uiNode.invokeUiUpdateListeners(UiUpdateState.CREATED); |
| return uiNode; |
| } |
| |
| /** |
| * Updates the {@link UiAttributeNode} list for this {@link UiElementNode} |
| * using the values from the XML element. |
| * <p/> |
| * For a given {@link UiElementNode}, the attribute list always exists in |
| * full and is totally independent of whether the XML model actually |
| * has the corresponding attributes. |
| * <p/> |
| * For each attribute declared in this {@link UiElementNode}, get |
| * the corresponding XML attribute. It may not exist, in which case the |
| * value will be null. We don't really know if a value has changed, so |
| * the updateValue() is called on the UI attribute in all cases. |
| * |
| * @param xmlNode The XML node to mirror |
| */ |
| protected void updateAttributeList(Node xmlNode) { |
| NamedNodeMap xmlAttrMap = xmlNode.getAttributes(); |
| HashSet<Node> visited = new HashSet<Node>(); |
| |
| // For all known (i.e. expected) UI attributes, find an existing XML attribute of |
| // same (uri, local name) and update the internal Ui attribute value. |
| for (UiAttributeNode uiAttr : getInternalUiAttributes().values()) { |
| AttributeDescriptor desc = uiAttr.getDescriptor(); |
| if (!(desc instanceof SeparatorAttributeDescriptor)) { |
| Node xmlAttr = xmlAttrMap == null ? null : |
| xmlAttrMap.getNamedItemNS(desc.getNamespaceUri(), desc.getXmlLocalName()); |
| uiAttr.updateValue(xmlAttr); |
| visited.add(xmlAttr); |
| } |
| } |
| |
| // Clone the current list of unknown attributes. We'll then remove from this list when |
| // we find attributes which are still unknown. What will be left are the old unknown |
| // attributes that have been deleted in the current XML attribute list. |
| @SuppressWarnings("unchecked") |
| HashSet<UiAttributeNode> deleted = (HashSet<UiAttributeNode>) mUnknownUiAttributes.clone(); |
| |
| // We need to ignore hidden attributes. |
| Map<String, AttributeDescriptor> hiddenAttrDesc = getHiddenAttributeDescriptors(); |
| |
| // Traverse the actual XML attribute list to find unknown attributes |
| if (xmlAttrMap != null) { |
| for (int i = 0; i < xmlAttrMap.getLength(); i++) { |
| Node xmlAttr = xmlAttrMap.item(i); |
| // Ignore attributes which have actual descriptors |
| if (visited.contains(xmlAttr)) { |
| continue; |
| } |
| |
| String xmlFullName = xmlAttr.getNodeName(); |
| |
| // Ignore attributes which are hidden (based on the prefix:localName key) |
| if (hiddenAttrDesc.containsKey(xmlFullName)) { |
| continue; |
| } |
| |
| String xmlAttrLocalName = xmlAttr.getLocalName(); |
| String xmlNsUri = xmlAttr.getNamespaceURI(); |
| |
| UiAttributeNode uiAttr = null; |
| for (UiAttributeNode a : mUnknownUiAttributes) { |
| String aLocalName = a.getDescriptor().getXmlLocalName(); |
| String aNsUri = a.getDescriptor().getNamespaceUri(); |
| if (aLocalName.equals(xmlAttrLocalName) && |
| (aNsUri == xmlNsUri || (aNsUri != null && aNsUri.equals(xmlNsUri)))) { |
| // This attribute is still present in the unknown list |
| uiAttr = a; |
| // It has not been deleted |
| deleted.remove(a); |
| break; |
| } |
| } |
| if (uiAttr == null) { |
| uiAttr = addUnknownAttribute(xmlFullName, xmlAttrLocalName, xmlNsUri); |
| } |
| |
| uiAttr.updateValue(xmlAttr); |
| } |
| |
| // Remove from the internal list unknown attributes that have been deleted from the xml |
| for (UiAttributeNode a : deleted) { |
| mUnknownUiAttributes.remove(a); |
| mCachedAllUiAttributes = null; |
| } |
| } |
| } |
| |
| /** |
| * Create a new temporary text attribute descriptor for the unknown attribute |
| * and returns a new {@link UiAttributeNode} associated to this descriptor. |
| * <p/> |
| * The attribute is not marked as dirty, doing so is up to the caller. |
| */ |
| private UiAttributeNode addUnknownAttribute(String xmlFullName, |
| String xmlAttrLocalName, String xmlNsUri) { |
| // Create a new unknown attribute of format string |
| TextAttributeDescriptor desc = new TextAttributeDescriptor( |
| xmlAttrLocalName, // xml name |
| xmlNsUri, // ui name |
| new AttributeInfo(xmlAttrLocalName, Format.STRING_SET) |
| ); |
| UiAttributeNode uiAttr = desc.createUiNode(this); |
| mUnknownUiAttributes.add(uiAttr); |
| mCachedAllUiAttributes = null; |
| return uiAttr; |
| } |
| |
| /** |
| * Invoke all registered {@link IUiUpdateListener} listening on this UI update for this node. |
| */ |
| protected void invokeUiUpdateListeners(UiUpdateState state) { |
| if (mUiUpdateListeners != null) { |
| for (IUiUpdateListener listener : mUiUpdateListeners) { |
| try { |
| listener.uiElementNodeUpdated(this, state); |
| } catch (Exception e) { |
| // prevent a crashing listener from crashing the whole invocation chain |
| AdtPlugin.log(e, "UIElement Listener failed: %s, state=%s", //$NON-NLS-1$ |
| getBreadcrumbTrailDescription(true), |
| state.toString()); |
| } |
| } |
| } |
| } |
| |
| // --- for derived implementations only --- |
| |
| @VisibleForTesting |
| public void setXmlNode(Node xmlNode) { |
| mXmlNode = xmlNode; |
| } |
| |
| public void refreshUi() { |
| invokeUiUpdateListeners(UiUpdateState.ATTR_UPDATED); |
| } |
| |
| |
| // ------------- Helpers |
| |
| /** |
| * Helper method to commit a single attribute value to XML. |
| * <p/> |
| * This method updates the XML regardless of the current XML value. |
| * Callers should check first if an update is needed. |
| * If the new value is empty, the XML attribute will be actually removed. |
| * <p/> |
| * Note that the caller MUST ensure that modifying the underlying XML model is |
| * safe and must take care of marking the model as dirty if necessary. |
| * |
| * @see AndroidXmlEditor#wrapEditXmlModel(Runnable) |
| * |
| * @param uiAttr The attribute node to commit. Must be a child of this UiElementNode. |
| * @param newValue The new value to set. |
| * @return True if the XML attribute was modified or removed, false if nothing changed. |
| */ |
| public boolean commitAttributeToXml(UiAttributeNode uiAttr, String newValue) { |
| // Get (or create) the underlying XML element node that contains the attributes. |
| Node element = prepareCommit(); |
| if (element != null && uiAttr != null) { |
| String attrLocalName = uiAttr.getDescriptor().getXmlLocalName(); |
| String attrNsUri = uiAttr.getDescriptor().getNamespaceUri(); |
| |
| NamedNodeMap attrMap = element.getAttributes(); |
| if (newValue == null || newValue.length() == 0) { |
| // Remove attribute if it's empty |
| if (attrMap.getNamedItemNS(attrNsUri, attrLocalName) != null) { |
| attrMap.removeNamedItemNS(attrNsUri, attrLocalName); |
| return true; |
| } |
| } else { |
| // Add or replace an attribute |
| Document doc = element.getOwnerDocument(); |
| if (doc != null) { |
| Attr attr; |
| if (attrNsUri != null && attrNsUri.length() > 0) { |
| attr = (Attr) attrMap.getNamedItemNS(attrNsUri, attrLocalName); |
| if (attr == null) { |
| attr = doc.createAttributeNS(attrNsUri, attrLocalName); |
| attr.setPrefix(XmlUtils.lookupNamespacePrefix(element, attrNsUri)); |
| attrMap.setNamedItemNS(attr); |
| } |
| } else { |
| attr = (Attr) attrMap.getNamedItem(attrLocalName); |
| if (attr == null) { |
| attr = doc.createAttribute(attrLocalName); |
| attrMap.setNamedItem(attr); |
| } |
| } |
| attr.setValue(newValue); |
| return true; |
| } |
| } |
| } |
| return false; |
| } |
| |
| /** |
| * Helper method to commit all dirty attributes values to XML. |
| * <p/> |
| * This method is useful if {@link #setAttributeValue(String, String, String, boolean)} has |
| * been called more than once and all the attributes marked as dirty must be committed to |
| * the XML. It calls {@link #commitAttributeToXml(UiAttributeNode, String)} on each dirty |
| * attribute. |
| * <p/> |
| * Note that the caller MUST ensure that modifying the underlying XML model is |
| * safe and must take care of marking the model as dirty if necessary. |
| * |
| * @see AndroidXmlEditor#wrapEditXmlModel(Runnable) |
| * |
| * @return True if one or more values were actually modified or removed, |
| * false if nothing changed. |
| */ |
| @SuppressWarnings("null") // Eclipse is confused by the logic and gets it wrong |
| public boolean commitDirtyAttributesToXml() { |
| boolean result = false; |
| List<UiAttributeNode> dirtyAttributes = new ArrayList<UiAttributeNode>(); |
| for (UiAttributeNode uiAttr : getAllUiAttributes()) { |
| if (uiAttr.isDirty()) { |
| String value = uiAttr.getCurrentValue(); |
| if (value != null && value.length() > 0) { |
| // Defer the new attributes: set these last and in order |
| dirtyAttributes.add(uiAttr); |
| } else { |
| result |= commitAttributeToXml(uiAttr, value); |
| uiAttr.setDirty(false); |
| } |
| } |
| } |
| if (dirtyAttributes.size() > 0) { |
| result = true; |
| |
| Collections.sort(dirtyAttributes); |
| |
| // The Eclipse XML model will *always* append new attributes. |
| // Therefore, if any of the dirty attributes are new, they will appear |
| // after any existing, clean attributes on the element. To fix this, |
| // we need to first remove any of these attributes, then insert them |
| // back in the right order. |
| Node element = prepareCommit(); |
| if (element == null) { |
| return result; |
| } |
| |
| if (AdtPrefs.getPrefs().getFormatGuiXml() && getEditor().supportsFormatOnGuiEdit()) { |
| // If auto formatting, don't bother with attribute sorting here since the |
| // order will be corrected as soon as the edit is committed anyway |
| for (UiAttributeNode uiAttribute : dirtyAttributes) { |
| commitAttributeToXml(uiAttribute, uiAttribute.getCurrentValue()); |
| uiAttribute.setDirty(false); |
| } |
| |
| return result; |
| } |
| |
| AttributeDescriptor descriptor = dirtyAttributes.get(0).getDescriptor(); |
| String firstName = descriptor.getXmlLocalName(); |
| String firstNamePrefix = null; |
| String namespaceUri = descriptor.getNamespaceUri(); |
| if (namespaceUri != null) { |
| firstNamePrefix = XmlUtils.lookupNamespacePrefix(element, namespaceUri); |
| } |
| NamedNodeMap attributes = ((Element) element).getAttributes(); |
| List<Attr> move = new ArrayList<Attr>(); |
| for (int i = 0, n = attributes.getLength(); i < n; i++) { |
| Attr attribute = (Attr) attributes.item(i); |
| if (XmlAttributeSortOrder.compareAttributes( |
| attribute.getPrefix(), attribute.getLocalName(), |
| firstNamePrefix, firstName) > 0) { |
| move.add(attribute); |
| } |
| } |
| |
| for (Attr attribute : move) { |
| if (attribute.getNamespaceURI() != null) { |
| attributes.removeNamedItemNS(attribute.getNamespaceURI(), |
| attribute.getLocalName()); |
| } else { |
| attributes.removeNamedItem(attribute.getName()); |
| } |
| } |
| |
| // Merge back the removed DOM attribute nodes and the new UI attribute nodes. |
| // In cases where the attribute DOM name and the UI attribute names equal, |
| // skip the DOM nodes and just apply the UI attributes. |
| int domAttributeIndex = 0; |
| int domAttributeIndexMax = move.size(); |
| int uiAttributeIndex = 0; |
| int uiAttributeIndexMax = dirtyAttributes.size(); |
| |
| while (true) { |
| Attr domAttribute; |
| UiAttributeNode uiAttribute; |
| |
| int compare; |
| if (uiAttributeIndex < uiAttributeIndexMax) { |
| if (domAttributeIndex < domAttributeIndexMax) { |
| domAttribute = move.get(domAttributeIndex); |
| uiAttribute = dirtyAttributes.get(uiAttributeIndex); |
| |
| String domAttributeName = domAttribute.getLocalName(); |
| String uiAttributeName = uiAttribute.getDescriptor().getXmlLocalName(); |
| compare = XmlAttributeSortOrder.compareAttributes(domAttributeName, |
| uiAttributeName); |
| } else { |
| compare = 1; |
| uiAttribute = dirtyAttributes.get(uiAttributeIndex); |
| domAttribute = null; |
| } |
| } else if (domAttributeIndex < domAttributeIndexMax) { |
| compare = -1; |
| domAttribute = move.get(domAttributeIndex); |
| uiAttribute = null; |
| } else { |
| break; |
| } |
| |
| if (compare < 0) { |
| if (domAttribute.getNamespaceURI() != null) { |
| attributes.setNamedItemNS(domAttribute); |
| } else { |
| attributes.setNamedItem(domAttribute); |
| } |
| domAttributeIndex++; |
| } else { |
| assert compare >= 0; |
| if (compare == 0) { |
| domAttributeIndex++; |
| } |
| commitAttributeToXml(uiAttribute, uiAttribute.getCurrentValue()); |
| uiAttribute.setDirty(false); |
| uiAttributeIndex++; |
| } |
| } |
| } |
| |
| return result; |
| } |
| |
| /** |
| * Utility method to internally set the value of a text attribute for the current |
| * UiElementNode. |
| * <p/> |
| * This method is a helper. It silently ignores the errors such as the requested |
| * attribute not being present in the element or attribute not being settable. |
| * It accepts inherited attributes (such as layout). |
| * <p/> |
| * This does not commit to the XML model. It does mark the attribute node as dirty. |
| * This is up to the caller. |
| * |
| * @see #commitAttributeToXml(UiAttributeNode, String) |
| * @see #commitDirtyAttributesToXml() |
| * |
| * @param attrXmlName The XML <em>local</em> name of the attribute to modify |
| * @param attrNsUri The namespace URI of the attribute. |
| * Can be null if the attribute uses the global namespace. |
| * @param value The new value for the attribute. If set to null, the attribute is removed. |
| * @param override True if the value must be set even if one already exists. |
| * @return The {@link UiAttributeNode} that has been modified or null. |
| */ |
| public UiAttributeNode setAttributeValue( |
| String attrXmlName, |
| String attrNsUri, |
| String value, |
| boolean override) { |
| if (value == null) { |
| value = ""; //$NON-NLS-1$ -- this removes an attribute |
| } |
| |
| getEditor().scheduleNodeReformat(this, true); |
| |
| // Try with all internal attributes |
| UiAttributeNode uiAttr = setInternalAttrValue( |
| getAllUiAttributes(), attrXmlName, attrNsUri, value, override); |
| if (uiAttr != null) { |
| return uiAttr; |
| } |
| |
| if (uiAttr == null) { |
| // Failed to find the attribute. For non-android attributes that is mostly expected, |
| // in which case we just create a new custom one. As a side effect, we'll find the |
| // attribute descriptor via getAllUiAttributes(). |
| addUnknownAttribute(attrXmlName, attrXmlName, attrNsUri); |
| |
| // We've created the attribute, but not actually set the value on it, so let's do it. |
| // Try with the updated internal attributes. |
| // Implementation detail: we could just do a setCurrentValue + setDirty on the |
| // uiAttr returned by addUnknownAttribute(); however going through setInternalAttrValue |
| // means we won't duplicate the logic, at the expense of doing one more lookup. |
| uiAttr = setInternalAttrValue( |
| getAllUiAttributes(), attrXmlName, attrNsUri, value, override); |
| } |
| |
| return uiAttr; |
| } |
| |
| private UiAttributeNode setInternalAttrValue( |
| Collection<UiAttributeNode> attributes, |
| String attrXmlName, |
| String attrNsUri, |
| String value, |
| boolean override) { |
| |
| // For namespace less attributes (like the "layout" attribute of an <include> tag |
| // we may be passed "" as the namespace (during an attribute copy), and it |
| // should really be null instead. |
| if (attrNsUri != null && attrNsUri.length() == 0) { |
| attrNsUri = null; |
| } |
| |
| for (UiAttributeNode uiAttr : attributes) { |
| AttributeDescriptor uiDesc = uiAttr.getDescriptor(); |
| |
| if (uiDesc.getXmlLocalName().equals(attrXmlName)) { |
| // Both NS URI must be either null or equal. |
| if ((attrNsUri == null && uiDesc.getNamespaceUri() == null) || |
| (attrNsUri != null && attrNsUri.equals(uiDesc.getNamespaceUri()))) { |
| |
| // Not all attributes are editable, ignore those which are not. |
| if (uiAttr instanceof IUiSettableAttributeNode) { |
| String current = uiAttr.getCurrentValue(); |
| // Only update (and mark as dirty) if the attribute did not have any |
| // value or if the value was different. |
| if (override || current == null || !current.equals(value)) { |
| ((IUiSettableAttributeNode) uiAttr).setCurrentValue(value); |
| // mark the attribute as dirty since their internal content |
| // as been modified, but not the underlying XML model |
| uiAttr.setDirty(true); |
| return uiAttr; |
| } |
| } |
| |
| // We found the attribute but it's not settable. Since attributes are |
| // not duplicated, just abandon here. |
| break; |
| } |
| } |
| } |
| |
| return null; |
| } |
| |
| /** |
| * Utility method to retrieve the internal value of an attribute. |
| * <p/> |
| * Note that this retrieves the *field* value if the attribute has some UI, and |
| * not the actual XML value. They may differ if the attribute is dirty. |
| * |
| * @param attrXmlName The XML name of the attribute to modify |
| * @return The current internal value for the attribute or null in case of error. |
| */ |
| public String getAttributeValue(String attrXmlName) { |
| HashMap<AttributeDescriptor, UiAttributeNode> attributeMap = getInternalUiAttributes(); |
| |
| for (Entry<AttributeDescriptor, UiAttributeNode> entry : attributeMap.entrySet()) { |
| AttributeDescriptor uiDesc = entry.getKey(); |
| if (uiDesc.getXmlLocalName().equals(attrXmlName)) { |
| UiAttributeNode uiAttr = entry.getValue(); |
| return uiAttr.getCurrentValue(); |
| } |
| } |
| return null; |
| } |
| |
| // ------ IPropertySource methods |
| |
| @Override |
| public Object getEditableValue() { |
| return null; |
| } |
| |
| /* |
| * (non-Javadoc) |
| * @see org.eclipse.ui.views.properties.IPropertySource#getPropertyDescriptors() |
| * |
| * Returns the property descriptor for this node. Since the descriptors are not linked to the |
| * data, the AttributeDescriptor are used directly. |
| */ |
| @Override |
| public IPropertyDescriptor[] getPropertyDescriptors() { |
| List<IPropertyDescriptor> propDescs = new ArrayList<IPropertyDescriptor>(); |
| |
| // get the standard descriptors |
| HashMap<AttributeDescriptor, UiAttributeNode> attributeMap = getInternalUiAttributes(); |
| Set<AttributeDescriptor> keys = attributeMap.keySet(); |
| |
| |
| // we only want the descriptor that do implement the IPropertyDescriptor interface. |
| for (AttributeDescriptor key : keys) { |
| if (key instanceof IPropertyDescriptor) { |
| propDescs.add((IPropertyDescriptor)key); |
| } |
| } |
| |
| // now get the descriptor from the unknown attributes |
| for (UiAttributeNode unknownNode : mUnknownUiAttributes) { |
| if (unknownNode.getDescriptor() instanceof IPropertyDescriptor) { |
| propDescs.add((IPropertyDescriptor)unknownNode.getDescriptor()); |
| } |
| } |
| |
| // TODO cache this maybe, as it's not going to change (except for unknown descriptors) |
| return propDescs.toArray(new IPropertyDescriptor[propDescs.size()]); |
| } |
| |
| /* |
| * (non-Javadoc) |
| * @see org.eclipse.ui.views.properties.IPropertySource#getPropertyValue(java.lang.Object) |
| * |
| * Returns the value of a given property. The id is the result of IPropertyDescriptor.getId(), |
| * which return the AttributeDescriptor itself. |
| */ |
| @Override |
| public Object getPropertyValue(Object id) { |
| HashMap<AttributeDescriptor, UiAttributeNode> attributeMap = getInternalUiAttributes(); |
| |
| UiAttributeNode attribute = attributeMap.get(id); |
| |
| if (attribute == null) { |
| // look for the id in the unknown attributes. |
| for (UiAttributeNode unknownAttr : mUnknownUiAttributes) { |
| if (id == unknownAttr.getDescriptor()) { |
| return unknownAttr; |
| } |
| } |
| } |
| |
| return attribute; |
| } |
| |
| /* |
| * (non-Javadoc) |
| * @see org.eclipse.ui.views.properties.IPropertySource#isPropertySet(java.lang.Object) |
| * |
| * Returns whether the property is set. In our case this is if the string is non empty. |
| */ |
| @Override |
| public boolean isPropertySet(Object id) { |
| HashMap<AttributeDescriptor, UiAttributeNode> attributeMap = getInternalUiAttributes(); |
| |
| UiAttributeNode attribute = attributeMap.get(id); |
| |
| if (attribute != null) { |
| return attribute.getCurrentValue().length() > 0; |
| } |
| |
| // look for the id in the unknown attributes. |
| for (UiAttributeNode unknownAttr : mUnknownUiAttributes) { |
| if (id == unknownAttr.getDescriptor()) { |
| return unknownAttr.getCurrentValue().length() > 0; |
| } |
| } |
| |
| return false; |
| } |
| |
| /* |
| * (non-Javadoc) |
| * @see org.eclipse.ui.views.properties.IPropertySource#resetPropertyValue(java.lang.Object) |
| * |
| * Reset the property to its default value. For now we simply empty it. |
| */ |
| @Override |
| public void resetPropertyValue(Object id) { |
| HashMap<AttributeDescriptor, UiAttributeNode> attributeMap = getInternalUiAttributes(); |
| |
| UiAttributeNode attribute = attributeMap.get(id); |
| if (attribute != null) { |
| // TODO: reset the value of the attribute |
| |
| return; |
| } |
| |
| // look for the id in the unknown attributes. |
| for (UiAttributeNode unknownAttr : mUnknownUiAttributes) { |
| if (id == unknownAttr.getDescriptor()) { |
| // TODO: reset the value of the attribute |
| |
| return; |
| } |
| } |
| } |
| |
| /* |
| * (non-Javadoc) |
| * @see org.eclipse.ui.views.properties.IPropertySource#setPropertyValue(java.lang.Object, java.lang.Object) |
| * |
| * Set the property value. id is the result of IPropertyDescriptor.getId(), which is the |
| * AttributeDescriptor itself. Value should be a String. |
| */ |
| @Override |
| public void setPropertyValue(Object id, Object value) { |
| HashMap<AttributeDescriptor, UiAttributeNode> attributeMap = getInternalUiAttributes(); |
| |
| UiAttributeNode attribute = attributeMap.get(id); |
| |
| if (attribute == null) { |
| // look for the id in the unknown attributes. |
| for (UiAttributeNode unknownAttr : mUnknownUiAttributes) { |
| if (id == unknownAttr.getDescriptor()) { |
| attribute = unknownAttr; |
| break; |
| } |
| } |
| } |
| |
| if (attribute != null) { |
| |
| // get the current value and compare it to the new value |
| String oldValue = attribute.getCurrentValue(); |
| final String newValue = (String)value; |
| |
| if (oldValue.equals(newValue)) { |
| return; |
| } |
| |
| final UiAttributeNode fAttribute = attribute; |
| AndroidXmlEditor editor = getEditor(); |
| editor.wrapEditXmlModel(new Runnable() { |
| @Override |
| public void run() { |
| commitAttributeToXml(fAttribute, newValue); |
| } |
| }); |
| } |
| } |
| |
| /** |
| * Returns true if this node is an ancestor (parent, grandparent, and so on) |
| * of the given node. Note that a node is not considered an ancestor of |
| * itself. |
| * |
| * @param node the node to test |
| * @return true if this node is an ancestor of the given node |
| */ |
| public boolean isAncestorOf(UiElementNode node) { |
| node = node.getUiParent(); |
| while (node != null) { |
| if (node == this) { |
| return true; |
| } |
| node = node.getUiParent(); |
| } |
| return false; |
| } |
| |
| /** |
| * Finds the nearest common parent of the two given nodes (which could be one of the |
| * two nodes as well) |
| * |
| * @param node1 the first node to test |
| * @param node2 the second node to test |
| * @return the nearest common parent of the two given nodes |
| */ |
| public static UiElementNode getCommonAncestor(UiElementNode node1, UiElementNode node2) { |
| while (node2 != null) { |
| UiElementNode current = node1; |
| while (current != null && current != node2) { |
| current = current.getUiParent(); |
| } |
| if (current == node2) { |
| return current; |
| } |
| node2 = node2.getUiParent(); |
| } |
| |
| return null; |
| } |
| |
| // ---- Global node create/delete Listeners ---- |
| |
| /** List of listeners to be notified of newly created nodes, or null */ |
| private static List<NodeCreationListener> sListeners; |
| |
| /** Notify listeners that a new node has been created */ |
| private void fireNodeCreated(UiElementNode newChild, int index) { |
| // Nothing to do if there aren't any listeners. We don't need to worry about |
| // the case where one thread is firing node changes while another is adding a listener |
| // (in that case it's still okay for this node firing not to be heard) so perform |
| // the check outside of synchronization. |
| if (sListeners == null) { |
| return; |
| } |
| synchronized (UiElementNode.class) { |
| if (sListeners != null) { |
| UiElementNode parent = newChild.getUiParent(); |
| for (NodeCreationListener listener : sListeners) { |
| listener.nodeCreated(parent, newChild, index); |
| } |
| } |
| } |
| } |
| |
| /** Notify listeners that a new node has been deleted */ |
| private void fireNodeDeleted(UiElementNode oldChild, int index) { |
| if (sListeners == null) { |
| return; |
| } |
| synchronized (UiElementNode.class) { |
| if (sListeners != null) { |
| UiElementNode parent = oldChild.getUiParent(); |
| for (NodeCreationListener listener : sListeners) { |
| listener.nodeDeleted(parent, oldChild, index); |
| } |
| } |
| } |
| } |
| |
| /** |
| * Adds a {@link NodeCreationListener} to be notified when new nodes are created |
| * |
| * @param listener the listener to be notified |
| */ |
| public static void addNodeCreationListener(NodeCreationListener listener) { |
| synchronized (UiElementNode.class) { |
| if (sListeners == null) { |
| sListeners = new ArrayList<NodeCreationListener>(1); |
| } |
| sListeners.add(listener); |
| } |
| } |
| |
| /** |
| * Removes a {@link NodeCreationListener} from the set of listeners such that it is |
| * no longer notified when nodes are created. |
| * |
| * @param listener the listener to be removed from the notification list |
| */ |
| public static void removeNodeCreationListener(NodeCreationListener listener) { |
| synchronized (UiElementNode.class) { |
| sListeners.remove(listener); |
| if (sListeners.size() == 0) { |
| sListeners = null; |
| } |
| } |
| } |
| |
| /** Interface implemented by listeners to be notified of newly created nodes */ |
| public interface NodeCreationListener { |
| /** |
| * Called when a new child node is created and added to the given parent |
| * |
| * @param parent the parent of the created node |
| * @param child the newly node |
| * @param index the index among the siblings of the child <b>after</b> |
| * insertion |
| */ |
| void nodeCreated(UiElementNode parent, UiElementNode child, int index); |
| |
| /** |
| * Called when a child node is removed from the given parent |
| * |
| * @param parent the parent of the removed node |
| * @param child the removed node |
| * @param previousIndex the index among the siblings of the child |
| * <b>before</b> removal |
| */ |
| void nodeDeleted(UiElementNode parent, UiElementNode child, int previousIndex); |
| } |
| } |
