| /* |
| * 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; |
| import static com.android.SdkConstants.ANDROID_PREFIX; |
| import static com.android.SdkConstants.ANDROID_THEME_PREFIX; |
| import static com.android.SdkConstants.ATTR_ID; |
| import static com.android.SdkConstants.ATTR_LAYOUT; |
| import static com.android.SdkConstants.ATTR_STYLE; |
| import static com.android.SdkConstants.PREFIX_RESOURCE_REF; |
| import static com.android.SdkConstants.PREFIX_THEME_REF; |
| |
| import com.android.annotations.NonNull; |
| import com.android.annotations.Nullable; |
| import com.android.ide.common.api.IAttributeInfo; |
| import com.android.ide.common.api.IAttributeInfo.Format; |
| import com.android.ide.common.resources.ResourceItem; |
| import com.android.ide.common.resources.ResourceRepository; |
| 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.DescriptorsUtils; |
| import com.android.ide.eclipse.adt.internal.editors.descriptors.TextAttributeDescriptor; |
| import com.android.ide.eclipse.adt.internal.editors.ui.SectionHelper; |
| import com.android.ide.eclipse.adt.internal.resources.manager.ResourceManager; |
| import com.android.ide.eclipse.adt.internal.sdk.AndroidTargetData; |
| import com.android.ide.eclipse.adt.internal.sdk.ProjectState; |
| import com.android.ide.eclipse.adt.internal.sdk.Sdk; |
| import com.android.ide.eclipse.adt.internal.ui.ReferenceChooserDialog; |
| import com.android.ide.eclipse.adt.internal.ui.ResourceChooser; |
| import com.android.resources.ResourceType; |
| |
| import org.eclipse.core.resources.IProject; |
| import org.eclipse.jface.window.Window; |
| import org.eclipse.swt.SWT; |
| import org.eclipse.swt.events.SelectionAdapter; |
| import org.eclipse.swt.events.SelectionEvent; |
| import org.eclipse.swt.layout.GridData; |
| import org.eclipse.swt.layout.GridLayout; |
| import org.eclipse.swt.widgets.Button; |
| import org.eclipse.swt.widgets.Composite; |
| import org.eclipse.swt.widgets.Label; |
| import org.eclipse.swt.widgets.Shell; |
| import org.eclipse.swt.widgets.Text; |
| import org.eclipse.ui.forms.IManagedForm; |
| import org.eclipse.ui.forms.widgets.FormToolkit; |
| import org.eclipse.ui.forms.widgets.TableWrapData; |
| |
| import java.util.ArrayList; |
| import java.util.Arrays; |
| import java.util.Collection; |
| import java.util.Collections; |
| import java.util.Comparator; |
| import java.util.EnumSet; |
| import java.util.HashSet; |
| import java.util.List; |
| import java.util.Set; |
| import java.util.regex.Matcher; |
| import java.util.regex.Pattern; |
| |
| /** |
| * Represents an XML attribute for a resource that can be modified using a simple text field or |
| * a dialog to choose an existing resource. |
| * <p/> |
| * It can be configured to represent any kind of resource, by providing the desired |
| * {@link ResourceType} in the constructor. |
| * <p/> |
| * See {@link UiTextAttributeNode} for more information. |
| */ |
| public class UiResourceAttributeNode extends UiTextAttributeNode { |
| private ResourceType mType; |
| |
| /** |
| * Creates a new {@linkplain UiResourceAttributeNode} |
| * |
| * @param type the associated resource type |
| * @param attributeDescriptor the attribute descriptor for this attribute |
| * @param uiParent the parent ui node, if any |
| */ |
| public UiResourceAttributeNode(ResourceType type, |
| AttributeDescriptor attributeDescriptor, UiElementNode uiParent) { |
| super(attributeDescriptor, uiParent); |
| |
| mType = type; |
| } |
| |
| /* (non-java doc) |
| * Creates a label widget and an associated text field. |
| * <p/> |
| * As most other parts of the android manifest editor, this assumes the |
| * parent uses a table layout with 2 columns. |
| */ |
| @Override |
| public void createUiControl(final Composite parent, IManagedForm managedForm) { |
| setManagedForm(managedForm); |
| FormToolkit toolkit = managedForm.getToolkit(); |
| TextAttributeDescriptor desc = (TextAttributeDescriptor) getDescriptor(); |
| |
| Label label = toolkit.createLabel(parent, desc.getUiName()); |
| label.setLayoutData(new TableWrapData(TableWrapData.LEFT, TableWrapData.MIDDLE)); |
| SectionHelper.addControlTooltip(label, DescriptorsUtils.formatTooltip(desc.getTooltip())); |
| |
| Composite composite = toolkit.createComposite(parent); |
| composite.setLayoutData(new TableWrapData(TableWrapData.FILL_GRAB, TableWrapData.MIDDLE)); |
| GridLayout gl = new GridLayout(2, false); |
| gl.marginHeight = gl.marginWidth = 0; |
| composite.setLayout(gl); |
| // Fixes missing text borders under GTK... also requires adding a 1-pixel margin |
| // for the text field below |
| toolkit.paintBordersFor(composite); |
| |
| final Text text = toolkit.createText(composite, getCurrentValue()); |
| GridData gd = new GridData(GridData.FILL_HORIZONTAL); |
| gd.horizontalIndent = 1; // Needed by the fixed composite borders under GTK |
| text.setLayoutData(gd); |
| Button browseButton = toolkit.createButton(composite, "Browse...", SWT.PUSH); |
| |
| setTextWidget(text); |
| |
| // TODO Add a validator using onAddModifyListener |
| |
| browseButton.addSelectionListener(new SelectionAdapter() { |
| @Override |
| public void widgetSelected(SelectionEvent e) { |
| String result = showDialog(parent.getShell(), text.getText().trim()); |
| if (result != null) { |
| text.setText(result); |
| } |
| } |
| }); |
| } |
| |
| /** |
| * Shows a dialog letting the user choose a set of enum, and returns a |
| * string containing the result. |
| * |
| * @param shell the parent shell |
| * @param currentValue an initial value, if any |
| * @return the chosen string, or null |
| */ |
| @Nullable |
| public String showDialog(@NonNull Shell shell, @Nullable String currentValue) { |
| // we need to get the project of the file being edited. |
| UiElementNode uiNode = getUiParent(); |
| AndroidXmlEditor editor = uiNode.getEditor(); |
| IProject project = editor.getProject(); |
| if (project != null) { |
| // get the resource repository for this project and the system resources. |
| ResourceRepository projectRepository = |
| ResourceManager.getInstance().getProjectResources(project); |
| |
| if (mType != null) { |
| // get the Target Data to get the system resources |
| AndroidTargetData data = editor.getTargetData(); |
| ResourceChooser dlg = ResourceChooser.create(project, mType, data, shell) |
| .setCurrentResource(currentValue); |
| if (dlg.open() == Window.OK) { |
| return dlg.getCurrentResource(); |
| } |
| } else { |
| ReferenceChooserDialog dlg = new ReferenceChooserDialog( |
| project, |
| projectRepository, |
| shell); |
| |
| dlg.setCurrentResource(currentValue); |
| |
| if (dlg.open() == Window.OK) { |
| return dlg.getCurrentResource(); |
| } |
| } |
| } |
| |
| return null; |
| } |
| |
| /** |
| * Gets all the values one could use to auto-complete a "resource" value in an XML |
| * content assist. |
| * <p/> |
| * Typically the user is editing the value of an attribute in a resource XML, e.g. |
| * <pre> "<Button android:test="@string/my_[caret]_string..." </pre> |
| * <p/> |
| * |
| * "prefix" is the value that the user has typed so far (or more exactly whatever is on the |
| * left side of the insertion point). In the example above it would be "@style/my_". |
| * <p/> |
| * |
| * To avoid a huge long list of values, the completion works on two levels: |
| * <ul> |
| * <li> If a resource type as been typed so far (e.g. "@style/"), then limit the values to |
| * the possible completions that match this type. |
| * <li> If no resource type as been typed so far, then return the various types that could be |
| * completed. So if the project has only strings and layouts resources, for example, |
| * the returned list will only include "@string/" and "@layout/". |
| * </ul> |
| * |
| * Finally if anywhere in the string we find the special token "android:", we use the |
| * current framework system resources rather than the project resources. |
| * This works for both "@android:style/foo" and "@style/android:foo" conventions even though |
| * the reconstructed name will always be of the former form. |
| * |
| * Note that "android:" here is a keyword specific to Android resources and should not be |
| * mixed with an XML namespace for an XML attribute name. |
| */ |
| @Override |
| public String[] getPossibleValues(String prefix) { |
| return computeResourceStringMatches(getUiParent().getEditor(), getDescriptor(), prefix); |
| } |
| |
| /** |
| * Computes the set of resource string matches for a given resource prefix in a given editor |
| * |
| * @param editor the editor context |
| * @param descriptor the attribute descriptor, if any |
| * @param prefix the prefix, if any |
| * @return an array of resource string matches |
| */ |
| @Nullable |
| public static String[] computeResourceStringMatches( |
| @NonNull AndroidXmlEditor editor, |
| @Nullable AttributeDescriptor descriptor, |
| @Nullable String prefix) { |
| |
| if (prefix == null || !prefix.regionMatches(1, ANDROID_PKG, 0, ANDROID_PKG.length())) { |
| IProject project = editor.getProject(); |
| if (project != null) { |
| // get the resource repository for this project and the system resources. |
| ResourceManager resourceManager = ResourceManager.getInstance(); |
| ResourceRepository repository = resourceManager.getProjectResources(project); |
| |
| List<IProject> libraries = null; |
| ProjectState projectState = Sdk.getProjectState(project); |
| if (projectState != null) { |
| libraries = projectState.getFullLibraryProjects(); |
| } |
| |
| String[] projectMatches = computeResourceStringMatches(descriptor, prefix, |
| repository, false); |
| |
| if (libraries == null || libraries.isEmpty()) { |
| return projectMatches; |
| } |
| |
| // Also compute matches for each of the libraries, and combine them |
| Set<String> matches = new HashSet<String>(200); |
| for (String s : projectMatches) { |
| matches.add(s); |
| } |
| |
| for (IProject library : libraries) { |
| repository = resourceManager.getProjectResources(library); |
| projectMatches = computeResourceStringMatches(descriptor, prefix, |
| repository, false); |
| for (String s : projectMatches) { |
| matches.add(s); |
| } |
| } |
| |
| String[] sorted = matches.toArray(new String[matches.size()]); |
| Arrays.sort(sorted); |
| return sorted; |
| } |
| } else { |
| // If there's a prefix with "android:" in it, use the system resources |
| // Non-public framework resources are filtered out later. |
| AndroidTargetData data = editor.getTargetData(); |
| if (data != null) { |
| ResourceRepository repository = data.getFrameworkResources(); |
| return computeResourceStringMatches(descriptor, prefix, repository, true); |
| } |
| } |
| |
| return null; |
| } |
| |
| /** |
| * Computes the set of resource string matches for a given prefix and a |
| * given resource repository |
| * |
| * @param attributeDescriptor the attribute descriptor, if any |
| * @param prefix the prefix, if any |
| * @param repository the repository to seaerch in |
| * @param isSystem if true, the repository contains framework repository, |
| * otherwise it contains project repositories |
| * @return an array of resource string matches |
| */ |
| @NonNull |
| public static String[] computeResourceStringMatches( |
| @Nullable AttributeDescriptor attributeDescriptor, |
| @Nullable String prefix, |
| @NonNull ResourceRepository repository, |
| boolean isSystem) { |
| // Get list of potential resource types, either specific to this project |
| // or the generic list. |
| Collection<ResourceType> resTypes = (repository != null) ? |
| repository.getAvailableResourceTypes() : |
| EnumSet.allOf(ResourceType.class); |
| |
| // Get the type name from the prefix, if any. It's any word before the / if there's one |
| String typeName = null; |
| if (prefix != null) { |
| Matcher m = Pattern.compile(".*?([a-z]+)/.*").matcher(prefix); //$NON-NLS-1$ |
| if (m.matches()) { |
| typeName = m.group(1); |
| } |
| } |
| |
| // Now collect results |
| List<String> results = new ArrayList<String>(); |
| |
| if (typeName == null) { |
| // This prefix does not have a / in it, so the resource string is either empty |
| // or does not have the resource type in it. Simply offer the list of potential |
| // resource types. |
| if (prefix != null && prefix.startsWith(PREFIX_THEME_REF)) { |
| results.add(ANDROID_THEME_PREFIX + ResourceType.ATTR.getName() + '/'); |
| if (resTypes.contains(ResourceType.ATTR) |
| || resTypes.contains(ResourceType.STYLE)) { |
| results.add(PREFIX_THEME_REF + ResourceType.ATTR.getName() + '/'); |
| if (prefix != null && prefix.startsWith(ANDROID_THEME_PREFIX)) { |
| // including attr isn't required |
| for (ResourceItem item : repository.getResourceItemsOfType( |
| ResourceType.ATTR)) { |
| results.add(ANDROID_THEME_PREFIX + item.getName()); |
| } |
| } |
| } |
| return results.toArray(new String[results.size()]); |
| } |
| |
| for (ResourceType resType : resTypes) { |
| if (isSystem) { |
| results.add(ANDROID_PREFIX + resType.getName() + '/'); |
| } else { |
| results.add('@' + resType.getName() + '/'); |
| } |
| if (resType == ResourceType.ID) { |
| // Also offer the + version to create an id from scratch |
| results.add("@+" + resType.getName() + '/'); //$NON-NLS-1$ |
| } |
| } |
| |
| // Also add in @android: prefix to completion such that if user has typed |
| // "@an" we offer to complete it. |
| if (prefix == null || |
| ANDROID_PKG.regionMatches(0, prefix, 1, prefix.length() - 1)) { |
| results.add(ANDROID_PREFIX); |
| } |
| } else if (repository != null) { |
| // We have a style name and a repository. Find all resources that match this |
| // type and recreate suggestions out of them. |
| |
| String initial = prefix != null && prefix.startsWith(PREFIX_THEME_REF) |
| ? PREFIX_THEME_REF : PREFIX_RESOURCE_REF; |
| ResourceType resType = ResourceType.getEnum(typeName); |
| if (resType != null) { |
| StringBuilder sb = new StringBuilder(); |
| sb.append(initial); |
| if (prefix != null && prefix.indexOf('+') >= 0) { |
| sb.append('+'); |
| } |
| |
| if (isSystem) { |
| sb.append(ANDROID_PKG).append(':'); |
| } |
| |
| sb.append(typeName).append('/'); |
| String base = sb.toString(); |
| |
| for (ResourceItem item : repository.getResourceItemsOfType(resType)) { |
| results.add(base + item.getName()); |
| } |
| |
| if (!isSystem && resType == ResourceType.ATTR) { |
| for (ResourceItem item : repository.getResourceItemsOfType( |
| ResourceType.STYLE)) { |
| results.add(base + item.getName()); |
| } |
| } |
| } |
| } |
| |
| if (attributeDescriptor != null) { |
| sortAttributeChoices(attributeDescriptor, results); |
| } else { |
| Collections.sort(results); |
| } |
| |
| return results.toArray(new String[results.size()]); |
| } |
| |
| /** |
| * Attempts to sort the attribute values to bubble up the most likely choices to |
| * the top. |
| * <p> |
| * For example, if you are editing a style attribute, it's likely that among the |
| * resource values you would rather see @style or @android than @string. |
| * @param descriptor the descriptor that the resource values are being completed for, |
| * used to prioritize some of the resource types |
| * @param choices the set of string resource values |
| */ |
| public static void sortAttributeChoices(AttributeDescriptor descriptor, |
| List<String> choices) { |
| final IAttributeInfo attributeInfo = descriptor.getAttributeInfo(); |
| Collections.sort(choices, new Comparator<String>() { |
| @Override |
| public int compare(String s1, String s2) { |
| int compare = score(attributeInfo, s1) - score(attributeInfo, s2); |
| if (compare == 0) { |
| // Sort alphabetically as a fallback |
| compare = s1.compareToIgnoreCase(s2); |
| } |
| return compare; |
| } |
| }); |
| } |
| |
| /** Compute a suitable sorting score for the given */ |
| private static final int score(IAttributeInfo attributeInfo, String value) { |
| if (value.equals(ANDROID_PREFIX)) { |
| return -1; |
| } |
| |
| for (Format format : attributeInfo.getFormats()) { |
| String type = null; |
| switch (format) { |
| case BOOLEAN: |
| type = "bool"; //$NON-NLS-1$ |
| break; |
| case COLOR: |
| type = "color"; //$NON-NLS-1$ |
| break; |
| case DIMENSION: |
| type = "dimen"; //$NON-NLS-1$ |
| break; |
| case INTEGER: |
| type = "integer"; //$NON-NLS-1$ |
| break; |
| case STRING: |
| type = "string"; //$NON-NLS-1$ |
| break; |
| // default: REFERENCE, FLAG, ENUM, etc - don't have type info about individual |
| // elements to help make a decision |
| } |
| |
| if (type != null) { |
| if (value.startsWith(PREFIX_RESOURCE_REF)) { |
| if (value.startsWith(PREFIX_RESOURCE_REF + type + '/')) { |
| return -2; |
| } |
| |
| if (value.startsWith(ANDROID_PREFIX + type + '/')) { |
| return -2; |
| } |
| } |
| if (value.startsWith(PREFIX_THEME_REF)) { |
| if (value.startsWith(PREFIX_THEME_REF + type + '/')) { |
| return -2; |
| } |
| |
| if (value.startsWith(ANDROID_THEME_PREFIX + type + '/')) { |
| return -2; |
| } |
| } |
| } |
| } |
| |
| // Handle a few more cases not covered by the Format metadata check |
| String type = null; |
| |
| String attribute = attributeInfo.getName(); |
| if (attribute.equals(ATTR_ID)) { |
| type = "id"; //$NON-NLS-1$ |
| } else if (attribute.equals(ATTR_STYLE)) { |
| type = "style"; //$NON-NLS-1$ |
| } else if (attribute.equals(ATTR_LAYOUT)) { |
| type = "layout"; //$NON-NLS-1$ |
| } else if (attribute.equals("drawable")) { //$NON-NLS-1$ |
| type = "drawable"; //$NON-NLS-1$ |
| } else if (attribute.equals("entries")) { //$NON-NLS-1$ |
| // Spinner |
| type = "array"; //$NON-NLS-1$ |
| } |
| |
| if (type != null) { |
| if (value.startsWith(PREFIX_RESOURCE_REF)) { |
| if (value.startsWith(PREFIX_RESOURCE_REF + type + '/')) { |
| return -2; |
| } |
| |
| if (value.startsWith(ANDROID_PREFIX + type + '/')) { |
| return -2; |
| } |
| } |
| if (value.startsWith(PREFIX_THEME_REF)) { |
| if (value.startsWith(PREFIX_THEME_REF + type + '/')) { |
| return -2; |
| } |
| |
| if (value.startsWith(ANDROID_THEME_PREFIX + type + '/')) { |
| return -2; |
| } |
| } |
| } |
| |
| return 0; |
| } |
| } |
