| /* |
| * 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; |
| |
| import static com.android.SdkConstants.ANDROID_URI; |
| import static com.android.SdkConstants.ATTR_LAYOUT_RESOURCE_PREFIX; |
| import static com.android.SdkConstants.PREFIX_ANDROID; |
| import static com.android.SdkConstants.PREFIX_RESOURCE_REF; |
| import static com.android.SdkConstants.PREFIX_THEME_REF; |
| import static com.android.SdkConstants.UNIT_DP; |
| import static com.android.SdkConstants.UNIT_IN; |
| import static com.android.SdkConstants.UNIT_MM; |
| import static com.android.SdkConstants.UNIT_PT; |
| import static com.android.SdkConstants.UNIT_PX; |
| import static com.android.SdkConstants.UNIT_SP; |
| import static com.android.ide.eclipse.adt.internal.editors.descriptors.AttributeDescriptor.ATTRIBUTE_ICON_FILENAME; |
| |
| import com.android.ide.common.api.IAttributeInfo; |
| import com.android.ide.common.api.IAttributeInfo.Format; |
| import com.android.ide.eclipse.adt.AdtPlugin; |
| 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.IDescriptorProvider; |
| import com.android.ide.eclipse.adt.internal.editors.descriptors.SeparatorAttributeDescriptor; |
| import com.android.ide.eclipse.adt.internal.editors.descriptors.TextValueDescriptor; |
| import com.android.ide.eclipse.adt.internal.editors.layout.gle2.DomUtilities; |
| import com.android.ide.eclipse.adt.internal.editors.uimodel.UiAttributeNode; |
| import com.android.ide.eclipse.adt.internal.editors.uimodel.UiElementNode; |
| import com.android.ide.eclipse.adt.internal.editors.uimodel.UiFlagAttributeNode; |
| import com.android.ide.eclipse.adt.internal.editors.uimodel.UiResourceAttributeNode; |
| import com.android.ide.eclipse.adt.internal.sdk.AndroidTargetData; |
| import com.android.utils.Pair; |
| import com.android.utils.XmlUtils; |
| |
| import org.eclipse.core.runtime.IStatus; |
| import org.eclipse.jdt.core.IType; |
| import org.eclipse.jdt.ui.ISharedImages; |
| import org.eclipse.jdt.ui.JavaUI; |
| import org.eclipse.jface.text.BadLocationException; |
| import org.eclipse.jface.text.IDocument; |
| import org.eclipse.jface.text.IRegion; |
| import org.eclipse.jface.text.ITextViewer; |
| import org.eclipse.jface.text.contentassist.ICompletionProposal; |
| import org.eclipse.jface.text.contentassist.IContentAssistProcessor; |
| import org.eclipse.jface.text.contentassist.IContextInformation; |
| import org.eclipse.jface.text.contentassist.IContextInformationValidator; |
| import org.eclipse.jface.text.source.ISourceViewer; |
| import org.eclipse.swt.graphics.Image; |
| import org.eclipse.wst.sse.core.internal.provisional.IndexedRegion; |
| import org.w3c.dom.Node; |
| |
| import java.util.ArrayList; |
| import java.util.Arrays; |
| import java.util.Comparator; |
| import java.util.EnumSet; |
| import java.util.HashMap; |
| import java.util.List; |
| import java.util.Map; |
| import java.util.regex.Pattern; |
| |
| /** |
| * Content Assist Processor for Android XML files |
| * <p> |
| * Remaining corner cases: |
| * <ul> |
| * <li>Completion does not work right if there is a space between the = and the opening |
| * quote. |
| * <li>Replacement completion does not work right if the caret is to the left of the |
| * opening quote, where the opening quote is a single quote, and the replacement items use |
| * double quotes. |
| * </ul> |
| */ |
| @SuppressWarnings("restriction") // XML model |
| public abstract class AndroidContentAssist implements IContentAssistProcessor { |
| |
| /** Regexp to detect a full attribute after an element tag. |
| * <pre>Syntax: |
| * name = "..." quoted string with all but < and " |
| * or: |
| * name = '...' quoted string with all but < and ' |
| * </pre> |
| */ |
| private static Pattern sFirstAttribute = Pattern.compile( |
| "^ *[a-zA-Z_:]+ *= *(?:\"[^<\"]*\"|'[^<']*')"); //$NON-NLS-1$ |
| |
| /** Regexp to detect an element tag name */ |
| private static Pattern sFirstElementWord = Pattern.compile("^[a-zA-Z0-9_:.-]+"); //$NON-NLS-1$ |
| |
| /** Regexp to detect whitespace */ |
| private static Pattern sWhitespace = Pattern.compile("\\s+"); //$NON-NLS-1$ |
| |
| protected final static String ROOT_ELEMENT = ""; |
| |
| /** Descriptor of the root of the XML hierarchy. This a "fake" ElementDescriptor which |
| * is used to list all the possible roots given by actual implementations. |
| * DO NOT USE DIRECTLY. Call {@link #getRootDescriptor()} instead. */ |
| private ElementDescriptor mRootDescriptor; |
| |
| private final int mDescriptorId; |
| |
| protected AndroidXmlEditor mEditor; |
| |
| /** |
| * Constructor for AndroidContentAssist |
| * @param descriptorId An id for {@link AndroidTargetData#getDescriptorProvider(int)}. |
| * The Id can be one of {@link AndroidTargetData#DESCRIPTOR_MANIFEST}, |
| * {@link AndroidTargetData#DESCRIPTOR_LAYOUT}, |
| * {@link AndroidTargetData#DESCRIPTOR_MENU}, |
| * or {@link AndroidTargetData#DESCRIPTOR_OTHER_XML}. |
| * All other values will throw an {@link IllegalArgumentException} later at runtime. |
| */ |
| public AndroidContentAssist(int descriptorId) { |
| mDescriptorId = descriptorId; |
| } |
| |
| /** |
| * Returns a list of completion proposals based on the |
| * specified location within the document that corresponds |
| * to the current cursor position within the text viewer. |
| * |
| * @param viewer the viewer whose document is used to compute the proposals |
| * @param offset an offset within the document for which completions should be computed |
| * @return an array of completion proposals or <code>null</code> if no proposals are possible |
| * |
| * @see org.eclipse.jface.text.contentassist.IContentAssistProcessor#computeCompletionProposals(org.eclipse.jface.text.ITextViewer, int) |
| */ |
| @Override |
| public ICompletionProposal[] computeCompletionProposals(ITextViewer viewer, int offset) { |
| String wordPrefix = extractElementPrefix(viewer, offset); |
| |
| if (mEditor == null) { |
| mEditor = AndroidXmlEditor.fromTextViewer(viewer); |
| if (mEditor == null) { |
| // This should not happen. Duck and forget. |
| AdtPlugin.log(IStatus.ERROR, "Editor not found during completion"); |
| return null; |
| } |
| } |
| |
| // List of proposals, in the order presented to the user. |
| List<ICompletionProposal> proposals = new ArrayList<ICompletionProposal>(80); |
| |
| // Look up the caret context - where in an element, or between elements, or |
| // within an element's children, is the given caret offset located? |
| Pair<Node, Node> context = DomUtilities.getNodeContext(viewer.getDocument(), offset); |
| if (context == null) { |
| return null; |
| } |
| Node parentNode = context.getFirst(); |
| Node currentNode = context.getSecond(); |
| assert parentNode != null || currentNode != null; |
| |
| UiElementNode rootUiNode = mEditor.getUiRootNode(); |
| if (currentNode == null || currentNode.getNodeType() == Node.TEXT_NODE) { |
| UiElementNode parentUiNode = |
| rootUiNode == null ? null : rootUiNode.findXmlNode(parentNode); |
| computeTextValues(proposals, offset, parentNode, currentNode, parentUiNode, |
| wordPrefix); |
| } else if (currentNode.getNodeType() == Node.ELEMENT_NODE) { |
| String parent = currentNode.getNodeName(); |
| AttribInfo info = parseAttributeInfo(viewer, offset, offset - wordPrefix.length()); |
| char nextChar = extractChar(viewer, offset); |
| if (info != null) { |
| // check to see if we can find a UiElementNode matching this XML node |
| UiElementNode currentUiNode = rootUiNode == null |
| ? null : rootUiNode.findXmlNode(currentNode); |
| computeAttributeProposals(proposals, viewer, offset, wordPrefix, currentUiNode, |
| parentNode, currentNode, parent, info, nextChar); |
| } else { |
| computeNonAttributeProposals(viewer, offset, wordPrefix, proposals, parentNode, |
| currentNode, parent, nextChar); |
| } |
| } |
| |
| return proposals.toArray(new ICompletionProposal[proposals.size()]); |
| } |
| |
| private void computeNonAttributeProposals(ITextViewer viewer, int offset, String wordPrefix, |
| List<ICompletionProposal> proposals, Node parentNode, Node currentNode, String parent, |
| char nextChar) { |
| if (startsWith(parent, wordPrefix)) { |
| // We are still editing the element's tag name, not the attributes |
| // (the element's tag name may not even be complete) |
| |
| Object[] choices = getChoicesForElement(parent, currentNode); |
| if (choices == null || choices.length == 0) { |
| return; |
| } |
| |
| int replaceLength = parent.length() - wordPrefix.length(); |
| boolean isNew = replaceLength == 0 && nextNonspaceChar(viewer, offset) == '<'; |
| // Special case: if we are right before the beginning of a new |
| // element, wipe out the replace length such that we insert before it, |
| // we don't edit the current element. |
| if (wordPrefix.length() == 0 && nextChar == '<') { |
| replaceLength = 0; |
| isNew = true; |
| } |
| |
| // If we found some suggestions, do we need to add an opening "<" bracket |
| // for the element? We don't if the cursor is right after "<" or "</". |
| // Per XML Spec, there's no whitespace between "<" or "</" and the tag name. |
| char needTag = computeElementNeedTag(viewer, offset, wordPrefix); |
| |
| addMatchingProposals(proposals, choices, offset, |
| parentNode != null ? parentNode : null, wordPrefix, needTag, |
| false /* isAttribute */, isNew, false /*isComplete*/, |
| replaceLength); |
| } |
| } |
| |
| private void computeAttributeProposals(List<ICompletionProposal> proposals, ITextViewer viewer, |
| int offset, String wordPrefix, UiElementNode currentUiNode, Node parentNode, |
| Node currentNode, String parent, AttribInfo info, char nextChar) { |
| // We're editing attributes in an element node (either the attributes' names |
| // or their values). |
| |
| if (info.isInValue) { |
| if (computeAttributeValues(proposals, offset, parent, info.name, currentNode, |
| wordPrefix, info.skipEndTag, info.replaceLength)) { |
| return; |
| } |
| } |
| |
| // Look up attribute proposals based on descriptors |
| Object[] choices = getChoicesForAttribute(parent, currentNode, currentUiNode, |
| info, wordPrefix); |
| if (choices == null || choices.length == 0) { |
| return; |
| } |
| |
| int replaceLength = info.replaceLength; |
| if (info.correctedPrefix != null) { |
| wordPrefix = info.correctedPrefix; |
| } |
| char needTag = info.needTag; |
| // Look to the right and see if we're followed by whitespace |
| boolean isNew = replaceLength == 0 |
| && (Character.isWhitespace(nextChar) || nextChar == '>' || nextChar == '/'); |
| |
| addMatchingProposals(proposals, choices, offset, parentNode != null ? parentNode : null, |
| wordPrefix, needTag, true /* isAttribute */, isNew, info.skipEndTag, |
| replaceLength); |
| } |
| |
| private char computeElementNeedTag(ITextViewer viewer, int offset, String wordPrefix) { |
| char needTag = 0; |
| int offset2 = offset - wordPrefix.length() - 1; |
| char c1 = extractChar(viewer, offset2); |
| if (!((c1 == '<') || (c1 == '/' && extractChar(viewer, offset2 - 1) == '<'))) { |
| needTag = '<'; |
| } |
| return needTag; |
| } |
| |
| protected int computeTextReplaceLength(Node currentNode, int offset) { |
| if (currentNode == null) { |
| return 0; |
| } |
| |
| assert currentNode != null && currentNode.getNodeType() == Node.TEXT_NODE; |
| |
| String nodeValue = currentNode.getNodeValue(); |
| int relativeOffset = offset - ((IndexedRegion) currentNode).getStartOffset(); |
| int lineEnd = nodeValue.indexOf('\n', relativeOffset); |
| if (lineEnd == -1) { |
| lineEnd = nodeValue.length(); |
| } |
| return lineEnd - relativeOffset; |
| } |
| |
| /** |
| * Gets the choices when the user is editing the name of an XML element. |
| * <p/> |
| * The user is editing the name of an element (the "parent"). |
| * Find the grand-parent and if one is found, return its children element list. |
| * The name which is being edited should be one of those. |
| * <p/> |
| * Example: <manifest><applic*cursor* => returns the list of all elements that |
| * can be found under <manifest>, of which <application> is one of the choices. |
| * |
| * @return an ElementDescriptor[] or null if no valid element was found. |
| */ |
| protected Object[] getChoicesForElement(String parent, Node currentNode) { |
| ElementDescriptor grandparent = null; |
| if (currentNode.getParentNode().getNodeType() == Node.ELEMENT_NODE) { |
| grandparent = getDescriptor(currentNode.getParentNode().getNodeName()); |
| } else if (currentNode.getParentNode().getNodeType() == Node.DOCUMENT_NODE) { |
| grandparent = getRootDescriptor(); |
| } |
| if (grandparent != null) { |
| for (ElementDescriptor e : grandparent.getChildren()) { |
| if (e.getXmlName().startsWith(parent)) { |
| return sort(grandparent.getChildren()); |
| } |
| } |
| } |
| |
| return null; |
| } |
| |
| /** Non-destructively sort a list of ElementDescriptors and return the result */ |
| protected static ElementDescriptor[] sort(ElementDescriptor[] elements) { |
| if (elements != null && elements.length > 1) { |
| // Sort alphabetically. Must make copy to not destroy original. |
| ElementDescriptor[] copy = new ElementDescriptor[elements.length]; |
| System.arraycopy(elements, 0, copy, 0, elements.length); |
| |
| Arrays.sort(copy, new Comparator<ElementDescriptor>() { |
| @Override |
| public int compare(ElementDescriptor e1, ElementDescriptor e2) { |
| return e1.getXmlLocalName().compareTo(e2.getXmlLocalName()); |
| } |
| }); |
| |
| return copy; |
| } |
| |
| return elements; |
| } |
| |
| /** |
| * Gets the choices when the user is editing an XML attribute. |
| * <p/> |
| * In input, attrInfo contains details on the analyzed context, namely whether the |
| * user is editing an attribute value (isInValue) or an attribute name. |
| * <p/> |
| * In output, attrInfo also contains two possible new values (this is a hack to circumvent |
| * the lack of out-parameters in Java): |
| * - AttribInfo.correctedPrefix if the user has been editing an attribute value and it has |
| * been detected that what the user typed is different from what extractElementPrefix() |
| * predicted. This happens because extractElementPrefix() stops when a character that |
| * cannot be an element name appears whereas parseAttributeInfo() uses a grammar more |
| * lenient as suitable for attribute values. |
| * - AttribInfo.needTag will be non-zero if we find that the attribute completion proposal |
| * must be double-quoted. |
| * @param currentUiNode |
| * |
| * @return an AttributeDescriptor[] if the user is editing an attribute name. |
| * a String[] if the user is editing an attribute value with some known values, |
| * or null if nothing is known about the context. |
| */ |
| private Object[] getChoicesForAttribute( |
| String parent, Node currentNode, UiElementNode currentUiNode, AttribInfo attrInfo, |
| String wordPrefix) { |
| Object[] choices = null; |
| if (attrInfo.isInValue) { |
| // Editing an attribute's value... Get the attribute name and then the |
| // possible choices for the tuple(parent,attribute) |
| String value = attrInfo.valuePrefix; |
| if (value.startsWith("'") || value.startsWith("\"")) { //$NON-NLS-1$ //$NON-NLS-2$ |
| value = value.substring(1); |
| // The prefix that was found at the beginning only scan for characters |
| // valid for tag name. We now know the real prefix for this attribute's |
| // value, which is needed to generate the completion choices below. |
| attrInfo.correctedPrefix = value; |
| } else { |
| attrInfo.needTag = '"'; |
| } |
| |
| if (currentUiNode != null) { |
| // look for an UI attribute matching the current attribute name |
| String attrName = attrInfo.name; |
| // remove any namespace prefix from the attribute name |
| int pos = attrName.indexOf(':'); |
| if (pos >= 0) { |
| attrName = attrName.substring(pos + 1); |
| } |
| |
| UiAttributeNode currAttrNode = null; |
| for (UiAttributeNode attrNode : currentUiNode.getAllUiAttributes()) { |
| if (attrNode.getDescriptor().getXmlLocalName().equals(attrName)) { |
| currAttrNode = attrNode; |
| break; |
| } |
| } |
| |
| if (currAttrNode != null) { |
| choices = getAttributeValueChoices(currAttrNode, attrInfo, value); |
| } |
| } |
| |
| if (choices == null) { |
| // fallback on the older descriptor-only based lookup. |
| |
| // in order to properly handle the special case of the name attribute in |
| // the action tag, we need the grandparent of the action node, to know |
| // what type of actions we need. |
| // e.g. activity -> intent-filter -> action[@name] |
| String greatGrandParentName = null; |
| Node grandParent = currentNode.getParentNode(); |
| if (grandParent != null) { |
| Node greatGrandParent = grandParent.getParentNode(); |
| if (greatGrandParent != null) { |
| greatGrandParentName = greatGrandParent.getLocalName(); |
| } |
| } |
| |
| AndroidTargetData data = mEditor.getTargetData(); |
| if (data != null) { |
| choices = data.getAttributeValues(parent, attrInfo.name, greatGrandParentName); |
| } |
| } |
| } else { |
| // Editing an attribute's name... Get attributes valid for the parent node. |
| if (currentUiNode != null) { |
| choices = currentUiNode.getAttributeDescriptors(); |
| } else { |
| ElementDescriptor parentDesc = getDescriptor(parent); |
| if (parentDesc != null) { |
| choices = parentDesc.getAttributes(); |
| } |
| } |
| } |
| return choices; |
| } |
| |
| protected Object[] getAttributeValueChoices(UiAttributeNode currAttrNode, AttribInfo attrInfo, |
| String value) { |
| Object[] choices; |
| int pos; |
| choices = currAttrNode.getPossibleValues(value); |
| if (choices != null && currAttrNode instanceof UiResourceAttributeNode) { |
| attrInfo.skipEndTag = false; |
| } |
| |
| if (currAttrNode instanceof UiFlagAttributeNode) { |
| // A "flag" can consist of several values separated by "or" (|). |
| // If the correct prefix contains such a pipe character, we change |
| // it so that only the currently edited value is completed. |
| pos = value.lastIndexOf('|'); |
| if (pos >= 0) { |
| attrInfo.correctedPrefix = value = value.substring(pos + 1); |
| attrInfo.needTag = 0; |
| } |
| |
| attrInfo.skipEndTag = false; |
| } |
| |
| // Should we do suffix completion on dimension units etc? |
| choices = completeSuffix(choices, value, currAttrNode); |
| |
| // Check to see if the user is attempting resource completion |
| AttributeDescriptor attributeDescriptor = currAttrNode.getDescriptor(); |
| IAttributeInfo attributeInfo = attributeDescriptor.getAttributeInfo(); |
| if (value.startsWith(PREFIX_RESOURCE_REF) |
| && !attributeInfo.getFormats().contains(Format.REFERENCE)) { |
| // Special case: If the attribute value looks like a reference to a |
| // resource, offer to complete it, since in many cases our metadata |
| // does not correctly state whether a resource value is allowed. We don't |
| // offer these for an empty completion context, but if the user has |
| // actually typed "@", in that case list resource matches. |
| // For example, for android:minHeight this makes completion on @dimen/ |
| // possible. |
| choices = UiResourceAttributeNode.computeResourceStringMatches( |
| mEditor, attributeDescriptor, value); |
| attrInfo.skipEndTag = false; |
| } else if (value.startsWith(PREFIX_THEME_REF) |
| && !attributeInfo.getFormats().contains(Format.REFERENCE)) { |
| choices = UiResourceAttributeNode.computeResourceStringMatches( |
| mEditor, attributeDescriptor, value); |
| attrInfo.skipEndTag = false; |
| } |
| |
| return choices; |
| } |
| |
| /** |
| * Compute attribute values. Return true if the complete set of values was |
| * added, so addition descriptor information should not be added. |
| */ |
| protected boolean computeAttributeValues(List<ICompletionProposal> proposals, int offset, |
| String parentTagName, String attributeName, Node node, String wordPrefix, |
| boolean skipEndTag, int replaceLength) { |
| return false; |
| } |
| |
| protected void computeTextValues(List<ICompletionProposal> proposals, int offset, |
| Node parentNode, Node currentNode, UiElementNode uiParent, |
| String wordPrefix) { |
| |
| if (parentNode != null) { |
| // Examine the parent of the text node. |
| Object[] choices = getElementChoicesForTextNode(parentNode); |
| if (choices != null && choices.length > 0) { |
| ISourceViewer viewer = mEditor.getStructuredSourceViewer(); |
| char needTag = computeElementNeedTag(viewer, offset, wordPrefix); |
| |
| int replaceLength = 0; |
| addMatchingProposals(proposals, choices, |
| offset, parentNode, wordPrefix, needTag, |
| false /* isAttribute */, |
| false /*isNew*/, |
| false /*isComplete*/, |
| replaceLength); |
| } |
| } |
| } |
| |
| /** |
| * Gets the choices when the user is editing an XML text node. |
| * <p/> |
| * This means the user is editing outside of any XML element or attribute. |
| * Simply return the list of XML elements that can be present there, based on the |
| * parent of the current node. |
| * |
| * @return An ElementDescriptor[] or null. |
| */ |
| protected ElementDescriptor[] getElementChoicesForTextNode(Node parentNode) { |
| ElementDescriptor[] choices = null; |
| String parent; |
| if (parentNode.getNodeType() == Node.ELEMENT_NODE) { |
| // We're editing a text node which parent is an element node. Limit |
| // content assist to elements valid for the parent. |
| parent = parentNode.getNodeName(); |
| ElementDescriptor desc = getDescriptor(parent); |
| if (desc == null && parent.indexOf('.') != -1) { |
| // The parent is a custom view and we don't have metadata about its |
| // allowable children, so just assume any normal layout tag is |
| // legal |
| desc = mRootDescriptor; |
| } |
| |
| if (desc != null) { |
| choices = sort(desc.getChildren()); |
| } |
| } else if (parentNode.getNodeType() == Node.DOCUMENT_NODE) { |
| // We're editing a text node at the first level (i.e. root node). |
| // Limit content assist to the only valid root elements. |
| choices = sort(getRootDescriptor().getChildren()); |
| } |
| |
| return choices; |
| } |
| |
| /** |
| * Given a list of choices, adds in any that match the current prefix into the |
| * proposals list. |
| * <p/> |
| * Choices is an object array. Items of the array can be: |
| * - ElementDescriptor: a possible element descriptor which XML name should be completed. |
| * - AttributeDescriptor: a possible attribute descriptor which XML name should be completed. |
| * - String: string values to display as-is to the user. Typically those are possible |
| * values for a given attribute. |
| * - Pair of Strings: the first value is the keyword to insert, and the second value |
| * is the tooltip/help for the value to be displayed in the documentation popup. |
| */ |
| protected void addMatchingProposals(List<ICompletionProposal> proposals, Object[] choices, |
| int offset, Node currentNode, String wordPrefix, char needTag, |
| boolean isAttribute, boolean isNew, boolean skipEndTag, int replaceLength) { |
| if (choices == null) { |
| return; |
| } |
| |
| Map<String, String> nsUriMap = new HashMap<String, String>(); |
| boolean haveLayoutParams = false; |
| |
| for (Object choice : choices) { |
| String keyword = null; |
| String nsPrefix = null; |
| String nsUri = null; |
| Image icon = null; |
| String tooltip = null; |
| if (choice instanceof ElementDescriptor) { |
| keyword = ((ElementDescriptor)choice).getXmlName(); |
| icon = ((ElementDescriptor)choice).getGenericIcon(); |
| // Tooltip computed lazily in {@link CompletionProposal} |
| } else if (choice instanceof TextValueDescriptor) { |
| continue; // Value nodes are not part of the completion choices |
| } else if (choice instanceof SeparatorAttributeDescriptor) { |
| continue; // not real attribute descriptors |
| } else if (choice instanceof AttributeDescriptor) { |
| keyword = ((AttributeDescriptor)choice).getXmlLocalName(); |
| icon = ((AttributeDescriptor)choice).getGenericIcon(); |
| // Tooltip computed lazily in {@link CompletionProposal} |
| |
| // Get the namespace URI for the attribute. Note that some attributes |
| // do not have a namespace and thus return null here. |
| nsUri = ((AttributeDescriptor)choice).getNamespaceUri(); |
| if (nsUri != null) { |
| nsPrefix = nsUriMap.get(nsUri); |
| if (nsPrefix == null) { |
| nsPrefix = XmlUtils.lookupNamespacePrefix(currentNode, nsUri, false); |
| nsUriMap.put(nsUri, nsPrefix); |
| } |
| } |
| if (nsPrefix != null) { |
| nsPrefix += ":"; //$NON-NLS-1$ |
| } |
| |
| } else if (choice instanceof String) { |
| keyword = (String) choice; |
| if (isAttribute) { |
| icon = IconFactory.getInstance().getIcon(ATTRIBUTE_ICON_FILENAME); |
| } |
| } else if (choice instanceof Pair<?, ?>) { |
| @SuppressWarnings("unchecked") |
| Pair<String, String> pair = (Pair<String, String>) choice; |
| keyword = pair.getFirst(); |
| tooltip = pair.getSecond(); |
| if (isAttribute) { |
| icon = IconFactory.getInstance().getIcon(ATTRIBUTE_ICON_FILENAME); |
| } |
| } else if (choice instanceof IType) { |
| IType type = (IType) choice; |
| keyword = type.getFullyQualifiedName(); |
| icon = JavaUI.getSharedImages().getImage(ISharedImages.IMG_OBJS_CUNIT); |
| } else { |
| continue; // discard unknown choice |
| } |
| |
| String nsKeyword = nsPrefix == null ? keyword : (nsPrefix + keyword); |
| |
| if (nameStartsWith(nsKeyword, wordPrefix, nsPrefix)) { |
| keyword = nsKeyword; |
| String endTag = ""; //$NON-NLS-1$ |
| if (needTag != 0) { |
| if (needTag == '"') { |
| keyword = needTag + keyword; |
| endTag = String.valueOf(needTag); |
| } else if (needTag == '<') { |
| if (elementCanHaveChildren(choice)) { |
| endTag = String.format("></%1$s>", keyword); //$NON-NLS-1$ |
| } else { |
| endTag = "/>"; //$NON-NLS-1$ |
| } |
| keyword = needTag + keyword + ' '; |
| } else if (needTag == ' ') { |
| keyword = needTag + keyword; |
| } |
| } else if (!isAttribute && isNew) { |
| if (elementCanHaveChildren(choice)) { |
| endTag = String.format("></%1$s>", keyword); //$NON-NLS-1$ |
| } else { |
| endTag = "/>"; //$NON-NLS-1$ |
| } |
| keyword = keyword + ' '; |
| } |
| |
| final String suffix; |
| int cursorPosition; |
| final String displayString; |
| if (choice instanceof AttributeDescriptor && isNew) { |
| // Special case for attributes: insert ="" stuff and locate caret inside "" |
| suffix = "=\"\""; //$NON-NLS-1$ |
| cursorPosition = keyword.length() + suffix.length() - 1; |
| displayString = keyword + endTag; // don't include suffix; |
| } else { |
| suffix = endTag; |
| cursorPosition = keyword.length(); |
| displayString = null; |
| } |
| |
| if (skipEndTag) { |
| assert isAttribute; |
| cursorPosition++; |
| } |
| |
| if (nsPrefix != null && |
| keyword.startsWith(ATTR_LAYOUT_RESOURCE_PREFIX, nsPrefix.length())) { |
| haveLayoutParams = true; |
| } |
| |
| // For attributes, automatically insert ns:attribute="" and place the cursor |
| // inside the quotes. |
| // Special case for attributes: insert ="" stuff and locate caret inside "" |
| proposals.add(new CompletionProposal( |
| this, |
| choice, |
| keyword + suffix, // String replacementString |
| offset - wordPrefix.length(), // int replacementOffset |
| wordPrefix.length() + replaceLength,// int replacementLength |
| cursorPosition, // cursorPosition |
| icon, // Image image |
| displayString, // displayString |
| null, // IContextInformation contextInformation |
| tooltip, // String additionalProposalInfo |
| nsPrefix, |
| nsUri |
| )); |
| } |
| } |
| |
| if (wordPrefix.length() > 0 && haveLayoutParams |
| && !wordPrefix.startsWith(ATTR_LAYOUT_RESOURCE_PREFIX)) { |
| // Sort layout parameters to the front if we automatically inserted some |
| // that you didn't request. For example, you typed "width" and we match both |
| // "width" and "layout_width" - should match layout_width. |
| String nsPrefix = nsUriMap.get(ANDROID_URI); |
| if (nsPrefix == null) { |
| nsPrefix = PREFIX_ANDROID; |
| } else { |
| nsPrefix += ':'; |
| } |
| if (!(wordPrefix.startsWith(nsPrefix) |
| && wordPrefix.startsWith(ATTR_LAYOUT_RESOURCE_PREFIX, nsPrefix.length()))) { |
| int nextLayoutIndex = 0; |
| for (int i = 0, n = proposals.size(); i < n; i++) { |
| ICompletionProposal proposal = proposals.get(i); |
| String keyword = proposal.getDisplayString(); |
| if (keyword.startsWith(nsPrefix) && |
| keyword.startsWith(ATTR_LAYOUT_RESOURCE_PREFIX, nsPrefix.length()) |
| && i != nextLayoutIndex) { |
| // Swap to front |
| ICompletionProposal temp = proposals.get(nextLayoutIndex); |
| proposals.set(nextLayoutIndex, proposal); |
| proposals.set(i, temp); |
| nextLayoutIndex++; |
| } |
| } |
| } |
| } |
| } |
| |
| /** |
| * Returns true if the given word starts with the given prefix. The comparison is not |
| * case sensitive. |
| * |
| * @param word the word to test |
| * @param prefix the prefix the word should start with |
| * @return true if the given word starts with the given prefix |
| */ |
| protected static boolean startsWith(String word, String prefix) { |
| int prefixLength = prefix.length(); |
| int wordLength = word.length(); |
| if (wordLength < prefixLength) { |
| return false; |
| } |
| |
| for (int i = 0; i < prefixLength; i++) { |
| if (Character.toLowerCase(prefix.charAt(i)) |
| != Character.toLowerCase(word.charAt(i))) { |
| return false; |
| } |
| } |
| |
| return true; |
| } |
| |
| /** @return the editor associated with this content assist */ |
| AndroidXmlEditor getEditor() { |
| return mEditor; |
| } |
| |
| /** |
| * This method performs a prefix match for the given word and prefix, with a couple of |
| * Android code completion specific twists: |
| * <ol> |
| * <li> The match is not case sensitive, so {word="fOo",prefix="FoO"} is a match. |
| * <li>If the word to be matched has a namespace prefix, the typed prefix doesn't have |
| * to match it. So {word="android:foo", prefix="foo"} is a match. |
| * <li>If the attribute name part starts with "layout_" it can be omitted. So |
| * {word="android:layout_marginTop",prefix="margin"} is a match, as is |
| * {word="android:layout_marginTop",prefix="android:margin"}. |
| * </ol> |
| * |
| * @param word the full word to be matched, including namespace if any |
| * @param prefix the prefix to check |
| * @param nsPrefix the namespace prefix (android: or local definition of android |
| * namespace prefix) |
| * @return true if the prefix matches for code completion |
| */ |
| protected static boolean nameStartsWith(String word, String prefix, String nsPrefix) { |
| if (nsPrefix == null) { |
| nsPrefix = ""; //$NON-NLS-1$ |
| } |
| |
| int wordStart = nsPrefix.length(); |
| int prefixStart = 0; |
| |
| if (startsWith(prefix, nsPrefix)) { |
| // Already matches up through the namespace prefix: |
| prefixStart = wordStart; |
| } else if (startsWith(nsPrefix, prefix)) { |
| return true; |
| } |
| |
| int prefixLength = prefix.length(); |
| int wordLength = word.length(); |
| |
| if (wordLength - wordStart < prefixLength - prefixStart) { |
| return false; |
| } |
| |
| boolean matches = true; |
| for (int i = prefixStart, j = wordStart; i < prefixLength; i++, j++) { |
| char c1 = Character.toLowerCase(prefix.charAt(i)); |
| char c2 = Character.toLowerCase(word.charAt(j)); |
| if (c1 != c2) { |
| matches = false; |
| break; |
| } |
| } |
| |
| if (!matches && word.startsWith(ATTR_LAYOUT_RESOURCE_PREFIX, wordStart) |
| && !prefix.startsWith(ATTR_LAYOUT_RESOURCE_PREFIX, prefixStart)) { |
| wordStart += ATTR_LAYOUT_RESOURCE_PREFIX.length(); |
| |
| if (wordLength - wordStart < prefixLength - prefixStart) { |
| return false; |
| } |
| |
| for (int i = prefixStart, j = wordStart; i < prefixLength; i++, j++) { |
| char c1 = Character.toLowerCase(prefix.charAt(i)); |
| char c2 = Character.toLowerCase(word.charAt(j)); |
| if (c1 != c2) { |
| return false; |
| } |
| } |
| |
| return true; |
| } |
| |
| return matches; |
| } |
| |
| /** |
| * Indicates whether this descriptor describes an element that can potentially |
| * have children (either sub-elements or text value). If an element can have children, |
| * we want to explicitly write an opening and a separate closing tag. |
| * <p/> |
| * Elements can have children if the descriptor has children element descriptors |
| * or if one of the attributes is a TextValueDescriptor. |
| * |
| * @param descriptor An ElementDescriptor or an AttributeDescriptor |
| * @return True if the descriptor is an ElementDescriptor that can have children or a text |
| * value |
| */ |
| private boolean elementCanHaveChildren(Object descriptor) { |
| if (descriptor instanceof ElementDescriptor) { |
| ElementDescriptor desc = (ElementDescriptor) descriptor; |
| if (desc.hasChildren()) { |
| return true; |
| } |
| for (AttributeDescriptor attrDesc : desc.getAttributes()) { |
| if (attrDesc instanceof TextValueDescriptor) { |
| return true; |
| } |
| } |
| } |
| return false; |
| } |
| |
| /** |
| * Returns the element descriptor matching a given XML node name or null if it can't be |
| * found. |
| * <p/> |
| * This is simplistic; ideally we should consider the parent's chain to make sure we |
| * can differentiate between different hierarchy trees. Right now the first match found |
| * is returned. |
| */ |
| private ElementDescriptor getDescriptor(String nodeName) { |
| return getRootDescriptor().findChildrenDescriptor(nodeName, true /* recursive */); |
| } |
| |
| @Override |
| public IContextInformation[] computeContextInformation(ITextViewer viewer, int offset) { |
| return null; |
| } |
| |
| /** |
| * Returns the characters which when entered by the user should |
| * automatically trigger the presentation of possible completions. |
| * |
| * In our case, we auto-activate on opening tags and attributes namespace. |
| * |
| * @return the auto activation characters for completion proposal or <code>null</code> |
| * if no auto activation is desired |
| */ |
| @Override |
| public char[] getCompletionProposalAutoActivationCharacters() { |
| return new char[]{ '<', ':', '=' }; |
| } |
| |
| @Override |
| public char[] getContextInformationAutoActivationCharacters() { |
| return null; |
| } |
| |
| @Override |
| public IContextInformationValidator getContextInformationValidator() { |
| return null; |
| } |
| |
| @Override |
| public String getErrorMessage() { |
| return null; |
| } |
| |
| /** |
| * Heuristically extracts the prefix used for determining template relevance |
| * from the viewer's document. The default implementation returns the String from |
| * offset backwards that forms a potential XML element name, attribute name or |
| * attribute value. |
| * |
| * The part were we access the document was extracted from |
| * org.eclipse.jface.text.templatesTemplateCompletionProcessor and adapted to our needs. |
| * |
| * @param viewer the viewer |
| * @param offset offset into document |
| * @return the prefix to consider |
| */ |
| protected String extractElementPrefix(ITextViewer viewer, int offset) { |
| int i = offset; |
| IDocument document = viewer.getDocument(); |
| if (i > document.getLength()) return ""; //$NON-NLS-1$ |
| |
| try { |
| for (; i > 0; --i) { |
| char ch = document.getChar(i - 1); |
| |
| // We want all characters that can form a valid: |
| // - element name, e.g. anything that is a valid Java class/variable literal. |
| // - attribute name, including : for the namespace |
| // - attribute value. |
| // Before we were inclusive and that made the code fragile. So now we're |
| // going to be exclusive: take everything till we get one of: |
| // - any form of whitespace |
| // - any xml separator, e.g. < > ' " and = |
| if (Character.isWhitespace(ch) || |
| ch == '<' || ch == '>' || ch == '\'' || ch == '"' || ch == '=') { |
| break; |
| } |
| } |
| |
| return document.get(i, offset - i); |
| } catch (BadLocationException e) { |
| return ""; //$NON-NLS-1$ |
| } |
| } |
| |
| /** |
| * Extracts the character at the given offset. |
| * Returns 0 if the offset is invalid. |
| */ |
| protected char extractChar(ITextViewer viewer, int offset) { |
| IDocument document = viewer.getDocument(); |
| if (offset > document.getLength()) return 0; |
| |
| try { |
| return document.getChar(offset); |
| } catch (BadLocationException e) { |
| return 0; |
| } |
| } |
| |
| /** |
| * Search forward and find the first non-space character and return it. Returns 0 if no |
| * such character was found. |
| */ |
| private char nextNonspaceChar(ITextViewer viewer, int offset) { |
| IDocument document = viewer.getDocument(); |
| int length = document.getLength(); |
| for (; offset < length; offset++) { |
| try { |
| char c = document.getChar(offset); |
| if (!Character.isWhitespace(c)) { |
| return c; |
| } |
| } catch (BadLocationException e) { |
| return 0; |
| } |
| } |
| |
| return 0; |
| } |
| |
| /** |
| * Information about the current edit of an attribute as reported by parseAttributeInfo. |
| */ |
| protected static class AttribInfo { |
| public AttribInfo() { |
| } |
| |
| /** True if the cursor is located in an attribute's value, false if in an attribute name */ |
| public boolean isInValue = false; |
| /** The attribute name. Null when not set. */ |
| public String name = null; |
| /** The attribute value top the left of the cursor. Null when not set. The value |
| * *may* start with a quote (' or "), in which case we know we don't need to quote |
| * the string for the user */ |
| public String valuePrefix = null; |
| /** String typed by the user so far (i.e. right before requesting code completion), |
| * which will be corrected if we find a possible completion for an attribute value. |
| * See the long comment in getChoicesForAttribute(). */ |
| public String correctedPrefix = null; |
| /** Non-zero if an attribute value need a start/end tag (i.e. quotes or brackets) */ |
| public char needTag = 0; |
| /** Number of characters to replace after the prefix */ |
| public int replaceLength = 0; |
| /** Should the cursor advance through the end tag when inserted? */ |
| public boolean skipEndTag = false; |
| } |
| |
| /** |
| * Try to guess if the cursor is editing an element's name or an attribute following an |
| * element. If it's an attribute, try to find if an attribute name is being defined or |
| * its value. |
| * <br/> |
| * This is currently *only* called when we know the cursor is after a complete element |
| * tag name, so it should never return null. |
| * <br/> |
| * Reference for XML syntax: http://www.w3.org/TR/2006/REC-xml-20060816/#sec-starttags |
| * <br/> |
| * @return An AttribInfo describing which attribute is being edited or null if the cursor is |
| * not editing an attribute (in which case it must be an element's name). |
| */ |
| private AttribInfo parseAttributeInfo(ITextViewer viewer, int offset, int prefixStartOffset) { |
| AttribInfo info = new AttribInfo(); |
| int originalOffset = offset; |
| |
| IDocument document = viewer.getDocument(); |
| int n = document.getLength(); |
| if (offset <= n) { |
| try { |
| // Look to the right to make sure we aren't sitting on the boundary of the |
| // beginning of a new element with whitespace before it |
| if (offset < n && document.getChar(offset) == '<') { |
| return null; |
| } |
| |
| n = offset; |
| for (;offset > 0; --offset) { |
| char ch = document.getChar(offset - 1); |
| if (ch == '>') break; |
| if (ch == '<') break; |
| } |
| |
| // text will contain the full string of the current element, |
| // i.e. whatever is after the "<" to the current cursor |
| String text = document.get(offset, n - offset); |
| |
| // Normalize whitespace to single spaces |
| text = sWhitespace.matcher(text).replaceAll(" "); //$NON-NLS-1$ |
| |
| // Remove the leading element name. By spec, it must be after the < without |
| // any whitespace. If there's nothing left, no attribute has been defined yet. |
| // Be sure to keep any whitespace after the initial word if any, as it matters. |
| text = sFirstElementWord.matcher(text).replaceFirst(""); //$NON-NLS-1$ |
| |
| // There MUST be space after the element name. If not, the cursor is still |
| // defining the element name. |
| if (!text.startsWith(" ")) { //$NON-NLS-1$ |
| return null; |
| } |
| |
| // Remove full attributes: |
| // Syntax: |
| // name = "..." quoted string with all but < and " |
| // or: |
| // name = '...' quoted string with all but < and ' |
| String temp; |
| do { |
| temp = text; |
| text = sFirstAttribute.matcher(temp).replaceFirst(""); //$NON-NLS-1$ |
| } while(!temp.equals(text)); |
| |
| IRegion lineInfo = document.getLineInformationOfOffset(originalOffset); |
| int lineStart = lineInfo.getOffset(); |
| String line = document.get(lineStart, lineInfo.getLength()); |
| int cursorColumn = originalOffset - lineStart; |
| int prefixLength = originalOffset - prefixStartOffset; |
| |
| // Now we're left with 3 cases: |
| // - nothing: either there is no attribute definition or the cursor located after |
| // a completed attribute definition. |
| // - a string with no =: the user is writing an attribute name. This case can be |
| // merged with the previous one. |
| // - string with an = sign, optionally followed by a quote (' or "): the user is |
| // writing the value of the attribute. |
| int posEqual = text.indexOf('='); |
| if (posEqual == -1) { |
| info.isInValue = false; |
| info.name = text.trim(); |
| |
| // info.name is currently just the prefix of the attribute name. |
| // Look at the text buffer to find the complete name (since we need |
| // to know its bounds in order to replace it when a different attribute |
| // that matches this prefix is chosen) |
| int nameStart = cursorColumn; |
| for (int nameEnd = nameStart; nameEnd < line.length(); nameEnd++) { |
| char c = line.charAt(nameEnd); |
| if (!(Character.isLetter(c) || c == ':' || c == '_')) { |
| String nameSuffix = line.substring(nameStart, nameEnd); |
| info.name = text.trim() + nameSuffix; |
| break; |
| } |
| } |
| |
| info.replaceLength = info.name.length() - prefixLength; |
| |
| if (info.name.length() == 0 && originalOffset > 0) { |
| // Ensure that attribute names are properly separated |
| char prevChar = extractChar(viewer, originalOffset - 1); |
| if (prevChar == '"' || prevChar == '\'') { |
| // Ensure that the attribute is properly separated from the |
| // previous element |
| info.needTag = ' '; |
| } |
| } |
| info.skipEndTag = false; |
| } else { |
| info.isInValue = true; |
| info.name = text.substring(0, posEqual).trim(); |
| info.valuePrefix = text.substring(posEqual + 1); |
| |
| char quoteChar = '"'; // Does " or ' surround the XML value? |
| for (int i = posEqual + 1; i < text.length(); i++) { |
| if (!Character.isWhitespace(text.charAt(i))) { |
| quoteChar = text.charAt(i); |
| break; |
| } |
| } |
| |
| // Must compute the complete value |
| int valueStart = cursorColumn; |
| int valueEnd = valueStart; |
| for (; valueEnd < line.length(); valueEnd++) { |
| char c = line.charAt(valueEnd); |
| if (c == quoteChar) { |
| // Make sure this isn't the *opening* quote of the value, |
| // which is the case if we invoke code completion with the |
| // caret between the = and the opening quote; in that case |
| // we consider it value completion, and offer items including |
| // the quotes, but we shouldn't bail here thinking we have found |
| // the end of the value. |
| // Look backwards to make sure we find another " before |
| // we find a = |
| boolean isFirst = false; |
| for (int j = valueEnd - 1; j >= 0; j--) { |
| char pc = line.charAt(j); |
| if (pc == '=') { |
| isFirst = true; |
| break; |
| } else if (pc == quoteChar) { |
| valueStart = j; |
| break; |
| } |
| } |
| if (!isFirst) { |
| info.skipEndTag = true; |
| break; |
| } |
| } |
| } |
| int valueEndOffset = valueEnd + lineStart; |
| info.replaceLength = valueEndOffset - (prefixStartOffset + prefixLength); |
| // Is the caret to the left of the value quote? If so, include it in |
| // the replace length. |
| int valueStartOffset = valueStart + lineStart; |
| if (valueStartOffset == prefixStartOffset && valueEnd > valueStart) { |
| info.replaceLength++; |
| } |
| } |
| return info; |
| } catch (BadLocationException e) { |
| // pass |
| } |
| } |
| |
| return null; |
| } |
| |
| /** Returns the root descriptor id to use */ |
| protected int getRootDescriptorId() { |
| return mDescriptorId; |
| } |
| |
| /** |
| * Computes (if needed) and returns the root descriptor. |
| */ |
| protected ElementDescriptor getRootDescriptor() { |
| if (mRootDescriptor == null) { |
| AndroidTargetData data = mEditor.getTargetData(); |
| if (data != null) { |
| IDescriptorProvider descriptorProvider = |
| data.getDescriptorProvider(getRootDescriptorId()); |
| |
| if (descriptorProvider != null) { |
| mRootDescriptor = new ElementDescriptor("", //$NON-NLS-1$ |
| descriptorProvider.getRootElementDescriptors()); |
| } |
| } |
| } |
| |
| return mRootDescriptor; |
| } |
| |
| /** |
| * Fixed list of dimension units, along with user documentation, for use by |
| * {@link #completeSuffix}. |
| */ |
| private static final String[] sDimensionUnits = new String[] { |
| UNIT_DP, |
| "<b>Density-independent Pixels</b> - an abstract unit that is based on the physical " |
| + "density of the screen.", |
| |
| UNIT_SP, |
| "<b>Scale-independent Pixels</b> - this is like the dp unit, but it is also scaled by " |
| + "the user's font size preference.", |
| |
| UNIT_PT, |
| "<b>Points</b> - 1/72 of an inch based on the physical size of the screen.", |
| |
| UNIT_MM, |
| "<b>Millimeters</b> - based on the physical size of the screen.", |
| |
| UNIT_IN, |
| "<b>Inches</b> - based on the physical size of the screen.", |
| |
| UNIT_PX, |
| "<b>Pixels</b> - corresponds to actual pixels on the screen. Not recommended.", |
| }; |
| |
| /** |
| * Fixed list of fractional units, along with user documentation, for use by |
| * {@link #completeSuffix} |
| */ |
| private static final String[] sFractionUnits = new String[] { |
| "%", //$NON-NLS-1$ |
| "<b>Fraction</b> - a percentage of the base size", |
| |
| "%p", //$NON-NLS-1$ |
| "<b>Fraction</b> - a percentage relative to parent container", |
| }; |
| |
| /** |
| * Completes suffixes for applicable types (like dimensions and fractions) such that |
| * after a dimension number you get completion on unit types like "px". |
| */ |
| private Object[] completeSuffix(Object[] choices, String value, UiAttributeNode currAttrNode) { |
| IAttributeInfo attributeInfo = currAttrNode.getDescriptor().getAttributeInfo(); |
| EnumSet<Format> formats = attributeInfo.getFormats(); |
| List<Object> suffixes = new ArrayList<Object>(); |
| |
| if (value.length() > 0 && Character.isDigit(value.charAt(0))) { |
| boolean hasDimension = formats.contains(Format.DIMENSION); |
| boolean hasFraction = formats.contains(Format.FRACTION); |
| |
| if (hasDimension || hasFraction) { |
| // Split up the value into a numeric part (the prefix) and the |
| // unit part (the suffix) |
| int suffixBegin = 0; |
| for (; suffixBegin < value.length(); suffixBegin++) { |
| if (!Character.isDigit(value.charAt(suffixBegin))) { |
| break; |
| } |
| } |
| String number = value.substring(0, suffixBegin); |
| String suffix = value.substring(suffixBegin); |
| |
| // Add in the matching dimension and/or fraction units, if any |
| if (hasDimension) { |
| // Each item has two entries in the array of strings: the first odd numbered |
| // ones are the unit names and the second even numbered ones are the |
| // corresponding descriptions. |
| for (int i = 0; i < sDimensionUnits.length; i += 2) { |
| String unit = sDimensionUnits[i]; |
| if (startsWith(unit, suffix)) { |
| String description = sDimensionUnits[i + 1]; |
| suffixes.add(Pair.of(number + unit, description)); |
| } |
| } |
| |
| // Allow "dip" completion but don't offer it ("dp" is preferred) |
| if (startsWith(suffix, "di") || startsWith(suffix, "dip")) { //$NON-NLS-1$ //$NON-NLS-2$ |
| suffixes.add(Pair.of(number + "dip", "Alternative name for \"dp\"")); //$NON-NLS-1$ |
| } |
| } |
| if (hasFraction) { |
| for (int i = 0; i < sFractionUnits.length; i += 2) { |
| String unit = sFractionUnits[i]; |
| if (startsWith(unit, suffix)) { |
| String description = sFractionUnits[i + 1]; |
| suffixes.add(Pair.of(number + unit, description)); |
| } |
| } |
| } |
| } |
| } |
| |
| boolean hasFlag = formats.contains(Format.FLAG); |
| if (hasFlag) { |
| boolean isDone = false; |
| String[] flagValues = attributeInfo.getFlagValues(); |
| for (String flagValue : flagValues) { |
| if (flagValue.equals(value)) { |
| isDone = true; |
| break; |
| } |
| } |
| if (isDone) { |
| // Add in all the new values with a separator of | |
| String currentValue = currAttrNode.getCurrentValue(); |
| for (String flagValue : flagValues) { |
| if (currentValue == null || !currentValue.contains(flagValue)) { |
| suffixes.add(value + '|' + flagValue); |
| } |
| } |
| } |
| } |
| |
| if (suffixes.size() > 0) { |
| // Merge previously added choices (from attribute enums etc) with the new matches |
| List<Object> all = new ArrayList<Object>(); |
| if (choices != null) { |
| for (Object s : choices) { |
| all.add(s); |
| } |
| } |
| all.addAll(suffixes); |
| choices = all.toArray(); |
| } |
| |
| return choices; |
| } |
| } |
