| /* |
| * 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.ui; |
| |
| import static com.android.SdkConstants.ANDROID_PREFIX; |
| import static com.android.SdkConstants.PREFIX_RESOURCE_REF; |
| |
| import com.android.annotations.NonNull; |
| import com.android.annotations.Nullable; |
| import com.android.ide.common.rendering.api.ResourceValue; |
| import com.android.ide.common.resources.ResourceItem; |
| import com.android.ide.common.resources.ResourceRepository; |
| import com.android.ide.common.resources.ResourceResolver; |
| import com.android.ide.eclipse.adt.AdtPlugin; |
| import com.android.ide.eclipse.adt.AdtUtils; |
| import com.android.ide.eclipse.adt.internal.assetstudio.OpenCreateAssetSetWizardAction; |
| import com.android.ide.eclipse.adt.internal.editors.layout.gle2.GraphicalEditorPart; |
| import com.android.ide.eclipse.adt.internal.editors.layout.properties.PropertyFactory; |
| import com.android.ide.eclipse.adt.internal.refactorings.extractstring.ExtractStringRefactoring; |
| import com.android.ide.eclipse.adt.internal.refactorings.extractstring.ExtractStringWizard; |
| import com.android.ide.eclipse.adt.internal.resources.ResourceHelper; |
| import com.android.ide.eclipse.adt.internal.resources.ResourceNameValidator; |
| import com.android.ide.eclipse.adt.internal.resources.manager.ProjectResources; |
| 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.resources.ResourceType; |
| import com.android.utils.Pair; |
| import com.google.common.collect.Maps; |
| |
| import org.eclipse.core.resources.IFile; |
| import org.eclipse.core.resources.IProject; |
| import org.eclipse.core.resources.IResource; |
| import org.eclipse.core.runtime.IStatus; |
| import org.eclipse.core.runtime.Status; |
| import org.eclipse.jface.dialogs.IDialogConstants; |
| import org.eclipse.jface.dialogs.IInputValidator; |
| import org.eclipse.jface.dialogs.InputDialog; |
| import org.eclipse.jface.text.IRegion; |
| import org.eclipse.jface.window.Window; |
| import org.eclipse.ltk.ui.refactoring.RefactoringWizard; |
| import org.eclipse.ltk.ui.refactoring.RefactoringWizardOpenOperation; |
| import org.eclipse.swt.SWT; |
| import org.eclipse.swt.events.ModifyEvent; |
| import org.eclipse.swt.events.ModifyListener; |
| 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.Control; |
| import org.eclipse.swt.widgets.Event; |
| import org.eclipse.swt.widgets.Label; |
| import org.eclipse.swt.widgets.Listener; |
| import org.eclipse.swt.widgets.Shell; |
| import org.eclipse.swt.widgets.Text; |
| import org.eclipse.ui.IWorkbench; |
| import org.eclipse.ui.PlatformUI; |
| import org.eclipse.ui.dialogs.AbstractElementListSelectionDialog; |
| import org.eclipse.ui.dialogs.SelectionStatusDialog; |
| |
| import java.util.ArrayList; |
| import java.util.Arrays; |
| import java.util.Collection; |
| import java.util.Collections; |
| import java.util.List; |
| import java.util.Locale; |
| import java.util.Map; |
| import java.util.regex.Matcher; |
| import java.util.regex.Pattern; |
| |
| /** |
| * A dialog to let the user select a resource based on a resource type. |
| */ |
| public class ResourceChooser extends AbstractElementListSelectionDialog implements ModifyListener { |
| /** The return code from the dialog for the user choosing "Clear" */ |
| public static final int CLEAR_RETURN_CODE = -5; |
| /** The dialog button ID for the user choosing "Clear" */ |
| private static final int CLEAR_BUTTON_ID = CLEAR_RETURN_CODE; |
| |
| private Pattern mProjectResourcePattern; |
| private ResourceType mResourceType; |
| private final List<ResourceRepository> mProjectResources; |
| private final ResourceRepository mFrameworkResources; |
| private Pattern mSystemResourcePattern; |
| private Button mProjectButton; |
| private Button mSystemButton; |
| private Button mNewButton; |
| private String mCurrentResource; |
| private final IProject mProject; |
| private IInputValidator mInputValidator; |
| |
| /** Helper object used to draw previews for drawables and colors. */ |
| private ResourcePreviewHelper mPreviewHelper; |
| |
| /** |
| * Textfield for editing the actual returned value, updated when selection |
| * changes. Only shown if {@link #mShowValueText} is true. |
| */ |
| private Text mEditValueText; |
| |
| /** |
| * Whether the {@link #mEditValueText} textfield should be shown when the dialog is created. |
| */ |
| private boolean mShowValueText; |
| |
| /** |
| * Flag indicating whether it's the first time {@link #handleSelectionChanged()} is called. |
| * This is used to filter out the first selection event, always called by the superclass |
| * when the widget is created, to distinguish between "the dialog was created" and |
| * "the user clicked on a selection result", since only the latter should wipe out the |
| * manual user edit shown in the value text. |
| */ |
| private boolean mFirstSelect = true; |
| |
| /** |
| * Label used to show the resolved value in the resource chooser. Only shown |
| * if the {@link #mResourceResolver} field is set. |
| */ |
| private Label mResolvedLabel; |
| |
| /** Resource resolver used to show actual values for resources selected. (Optional). */ |
| private ResourceResolver mResourceResolver; |
| |
| /** |
| * Creates a Resource Chooser dialog. |
| * @param project Project being worked on |
| * @param type The type of the resource to choose |
| * @param projectResources The repository for the project |
| * @param frameworkResources The Framework resource repository |
| * @param parent the parent shell |
| */ |
| private ResourceChooser( |
| @NonNull IProject project, |
| @NonNull ResourceType type, |
| @NonNull List<ResourceRepository> projectResources, |
| @Nullable ResourceRepository frameworkResources, |
| @NonNull Shell parent) { |
| super(parent, new ResourceLabelProvider()); |
| mProject = project; |
| |
| mResourceType = type; |
| mProjectResources = projectResources; |
| mFrameworkResources = frameworkResources; |
| |
| mProjectResourcePattern = Pattern.compile( |
| PREFIX_RESOURCE_REF + mResourceType.getName() + "/(.+)"); //$NON-NLS-1$ |
| |
| mSystemResourcePattern = Pattern.compile( |
| ANDROID_PREFIX + mResourceType.getName() + "/(.+)"); //$NON-NLS-1$ |
| |
| setTitle("Resource Chooser"); |
| setMessage(String.format("Choose a %1$s resource", |
| mResourceType.getDisplayName().toLowerCase(Locale.US))); |
| } |
| |
| /** |
| * Creates a new {@link ResourceChooser} |
| * |
| * @param editor the associated layout editor |
| * @param type the resource type to choose |
| * @return a new {@link ResourceChooser} |
| */ |
| @NonNull |
| public static ResourceChooser create( |
| @NonNull GraphicalEditorPart editor, |
| @NonNull ResourceType type) { |
| IProject project = editor.getProject(); |
| Shell parent = editor.getCanvasControl().getShell(); |
| AndroidTargetData targetData = editor.getEditorDelegate().getEditor().getTargetData(); |
| ResourceChooser chooser = create(project, type, targetData, parent); |
| |
| // When editing Strings, allow editing the value text directly. When we |
| // get inline editing support (where values entered directly into the |
| // textual widget are translated automatically into a resource) this can |
| // go away. |
| if (type == ResourceType.STRING) { |
| chooser.setResourceResolver(editor.getResourceResolver()); |
| chooser.setShowValueText(true); |
| } else if (type == ResourceType.DIMEN || type == ResourceType.INTEGER) { |
| chooser.setResourceResolver(editor.getResourceResolver()); |
| } |
| |
| chooser.setPreviewHelper(new ResourcePreviewHelper(chooser, editor)); |
| return chooser; |
| } |
| |
| /** |
| * Creates a new {@link ResourceChooser} |
| * |
| * @param project the associated project |
| * @param type the resource type to choose |
| * @param targetData the associated framework target data |
| * @param parent the target shell |
| * @return a new {@link ResourceChooser} |
| */ |
| @NonNull |
| public static ResourceChooser create( |
| @NonNull IProject project, |
| @NonNull ResourceType type, |
| @Nullable AndroidTargetData targetData, |
| @NonNull Shell parent) { |
| ResourceManager manager = ResourceManager.getInstance(); |
| |
| List<ResourceRepository> projectResources = new ArrayList<ResourceRepository>(); |
| ProjectResources resources = manager.getProjectResources(project); |
| projectResources.add(resources); |
| |
| // Add in library project resources |
| ProjectState projectState = Sdk.getProjectState(project); |
| if (projectState != null) { |
| List<IProject> libraries = projectState.getFullLibraryProjects(); |
| if (libraries != null && !libraries.isEmpty()) { |
| for (IProject library : libraries) { |
| projectResources.add(manager.getProjectResources(library)); |
| } |
| } |
| } |
| |
| ResourceRepository frameworkResources = |
| targetData != null ? targetData.getFrameworkResources() : null; |
| return new ResourceChooser(project, type, projectResources, frameworkResources, parent); |
| } |
| |
| /** |
| * Sets whether this dialog should show the value field as a separate text |
| * value (and take the resulting value of the dialog from this text field |
| * rather than from the selection) |
| * |
| * @param showValueText if true, show the value text field |
| * @return this, for constructor chaining |
| */ |
| public ResourceChooser setShowValueText(boolean showValueText) { |
| mShowValueText = showValueText; |
| |
| return this; |
| } |
| |
| /** |
| * Sets the resource resolver to use to show resolved values for the current |
| * selection |
| * |
| * @param resourceResolver the resource resolver to use |
| * @return this, for constructor chaining |
| */ |
| public ResourceChooser setResourceResolver(ResourceResolver resourceResolver) { |
| mResourceResolver = resourceResolver; |
| |
| return this; |
| } |
| |
| /** |
| * Sets the {@link ResourcePreviewHelper} to use to preview drawable |
| * resources, if any |
| * |
| * @param previewHelper the helper to use |
| * @return this, for constructor chaining |
| */ |
| public ResourceChooser setPreviewHelper(ResourcePreviewHelper previewHelper) { |
| mPreviewHelper = previewHelper; |
| |
| return this; |
| } |
| |
| /** |
| * Sets the initial dialog size |
| * |
| * @param width the initial width |
| * @param height the initial height |
| * @return this, for constructor chaining |
| */ |
| public ResourceChooser setInitialSize(int width, int height) { |
| setSize(width, height); |
| |
| return this; |
| } |
| |
| @Override |
| public void create() { |
| super.create(); |
| |
| if (mShowValueText) { |
| mEditValueText.selectAll(); |
| mEditValueText.setFocus(); |
| } |
| } |
| |
| @Override |
| protected void createButtonsForButtonBar(Composite parent) { |
| createButton(parent, CLEAR_BUTTON_ID, "Clear", false /*defaultButton*/); |
| super.createButtonsForButtonBar(parent); |
| } |
| |
| @Override |
| protected void buttonPressed(int buttonId) { |
| super.buttonPressed(buttonId); |
| |
| if (buttonId == CLEAR_BUTTON_ID) { |
| assert CLEAR_RETURN_CODE != Window.OK && CLEAR_RETURN_CODE != Window.CANCEL; |
| setReturnCode(CLEAR_RETURN_CODE); |
| close(); |
| } |
| } |
| |
| /** |
| * Sets the currently selected item |
| * |
| * @param resource the resource url for the currently selected item |
| * @return this, for constructor chaining |
| */ |
| public ResourceChooser setCurrentResource(@Nullable String resource) { |
| mCurrentResource = resource; |
| |
| if (mShowValueText && mEditValueText != null) { |
| mEditValueText.setText(resource); |
| } |
| |
| return this; |
| } |
| |
| /** |
| * Returns the currently selected url |
| * |
| * @return the currently selected url |
| */ |
| @Nullable |
| public String getCurrentResource() { |
| return mCurrentResource; |
| } |
| |
| /** |
| * Sets the input validator to use, if any |
| * |
| * @param inputValidator the validator |
| * @return this, for constructor chaining |
| */ |
| public ResourceChooser setInputValidator(@Nullable IInputValidator inputValidator) { |
| mInputValidator = inputValidator; |
| |
| return this; |
| } |
| |
| @Override |
| protected void computeResult() { |
| if (mShowValueText) { |
| mCurrentResource = mEditValueText.getText(); |
| if (mCurrentResource.length() == 0) { |
| mCurrentResource = null; |
| } |
| return; |
| } |
| |
| computeResultFromSelection(); |
| } |
| |
| private void computeResultFromSelection() { |
| if (getSelectionIndex() == -1) { |
| mCurrentResource = null; |
| return; |
| } |
| |
| Object[] elements = getSelectedElements(); |
| if (elements.length == 1 && elements[0] instanceof ResourceItem) { |
| ResourceItem item = (ResourceItem)elements[0]; |
| |
| mCurrentResource = item.getXmlString(mResourceType, mSystemButton.getSelection()); |
| |
| if (mInputValidator != null && mInputValidator.isValid(mCurrentResource) != null) { |
| mCurrentResource = null; |
| } |
| } |
| } |
| |
| @Override |
| protected Control createDialogArea(Composite parent) { |
| Composite top = (Composite)super.createDialogArea(parent); |
| |
| createMessageArea(top); |
| |
| createButtons(top); |
| createFilterText(top); |
| createFilteredList(top); |
| |
| // create the "New Resource" button |
| createNewResButtons(top); |
| |
| // Optionally create the value text field, if {@link #mShowValueText} is true |
| createValueField(top); |
| |
| setupResourceList(); |
| selectResourceString(mCurrentResource); |
| |
| return top; |
| } |
| |
| /** |
| * Creates the radio button to switch between project and system resources. |
| * @param top the parent composite |
| */ |
| private void createButtons(Composite top) { |
| mProjectButton = new Button(top, SWT.RADIO); |
| mProjectButton.setText("Project Resources"); |
| mProjectButton.addSelectionListener(new SelectionAdapter() { |
| @Override |
| public void widgetSelected(SelectionEvent e) { |
| super.widgetSelected(e); |
| if (mProjectButton.getSelection()) { |
| // Clear selection before changing the list contents. This works around |
| // a bug in the superclass where switching to the framework resources, |
| // choosing one of the last resources, then switching to the project |
| // resources would cause an exception when calling getSelection() because |
| // selection state doesn't get cleared when we set new contents on |
| // the filtered list. |
| fFilteredList.setSelection(new int[0]); |
| setupResourceList(); |
| updateNewButton(false /*isSystem*/); |
| updateValue(); |
| } |
| } |
| }); |
| mSystemButton = new Button(top, SWT.RADIO); |
| mSystemButton.setText("System Resources"); |
| mSystemButton.addSelectionListener(new SelectionAdapter() { |
| @Override |
| public void widgetSelected(SelectionEvent e) { |
| super.widgetSelected(e); |
| if (mSystemButton.getSelection()) { |
| fFilteredList.setSelection(new int[0]); |
| setupResourceList(); |
| updateNewButton(true /*isSystem*/); |
| updateValue(); |
| } |
| } |
| }); |
| if (mFrameworkResources == null) { |
| mSystemButton.setVisible(false); |
| } |
| } |
| |
| /** |
| * Creates the "New Resource" button. |
| * @param top the parent composite |
| */ |
| private void createNewResButtons(Composite top) { |
| mNewButton = new Button(top, SWT.NONE); |
| |
| String title = String.format("New %1$s...", mResourceType.getDisplayName()); |
| if (mResourceType == ResourceType.DRAWABLE) { |
| title = "Create New Icon..."; |
| } |
| mNewButton.setText(title); |
| |
| mNewButton.addSelectionListener(new SelectionAdapter() { |
| @Override |
| public void widgetSelected(SelectionEvent e) { |
| super.widgetSelected(e); |
| |
| if (mResourceType == ResourceType.STRING) { |
| // Special case: Use Extract String refactoring wizard UI |
| String newName = createNewString(); |
| selectAddedItem(newName); |
| } else if (mResourceType == ResourceType.DRAWABLE) { |
| // Special case: Use the "Create Icon Set" wizard |
| OpenCreateAssetSetWizardAction action = |
| new OpenCreateAssetSetWizardAction(mProject); |
| action.run(); |
| List<IResource> files = action.getCreatedFiles(); |
| if (files != null && files.size() > 0) { |
| String newName = AdtUtils.stripAllExtensions(files.get(0).getName()); |
| // Recompute the "current resource" to select the new id |
| ResourceItem[] items = setupResourceList(); |
| selectItemName(newName, items); |
| } |
| } else { |
| if (ResourceHelper.isValueBasedResourceType(mResourceType)) { |
| String newName = createNewValue(mResourceType); |
| if (newName != null) { |
| selectAddedItem(newName); |
| } |
| } else { |
| String newName = createNewFile(mResourceType); |
| if (newName != null) { |
| selectAddedItem(newName); |
| } |
| } |
| } |
| } |
| |
| private void selectAddedItem(@NonNull String newName) { |
| // Recompute the "current resource" to select the new id |
| ResourceItem[] items = setupResourceList(); |
| |
| // Ensure that the name is in the list. There's a delay after |
| // an item is added (until the builder runs and processes the delta) |
| // so if it's not in the list, add it |
| boolean found = false; |
| for (ResourceItem item : items) { |
| if (newName.equals(item.getName())) { |
| found = true; |
| break; |
| } |
| } |
| if (!found) { |
| ResourceItem[] newItems = new ResourceItem[items.length + 1]; |
| System.arraycopy(items, 0, newItems, 0, items.length); |
| newItems[items.length] = new ResourceItem(newName); |
| items = newItems; |
| Arrays.sort(items); |
| setListElements(items); |
| fFilteredList.setEnabled(newItems.length > 0); |
| } |
| |
| selectItemName(newName, items); |
| } |
| }); |
| } |
| |
| /** |
| * Creates the value text field. |
| * |
| * @param top the parent composite |
| */ |
| private void createValueField(Composite top) { |
| if (mShowValueText) { |
| mEditValueText = new Text(top, SWT.BORDER); |
| if (mCurrentResource != null) { |
| mEditValueText.setText(mCurrentResource); |
| } |
| mEditValueText.addModifyListener(this); |
| |
| GridData data = new GridData(); |
| data.grabExcessVerticalSpace = false; |
| data.grabExcessHorizontalSpace = true; |
| data.horizontalAlignment = GridData.FILL; |
| data.verticalAlignment = GridData.BEGINNING; |
| mEditValueText.setLayoutData(data); |
| mEditValueText.setFont(top.getFont()); |
| } |
| |
| if (mResourceResolver != null) { |
| mResolvedLabel = new Label(top, SWT.NONE); |
| GridData data = new GridData(); |
| data.grabExcessVerticalSpace = false; |
| data.grabExcessHorizontalSpace = true; |
| data.horizontalAlignment = GridData.FILL; |
| data.verticalAlignment = GridData.BEGINNING; |
| mResolvedLabel.setLayoutData(data); |
| } |
| |
| Composite workaround = PropertyFactory.addWorkaround(top); |
| if (workaround != null) { |
| workaround.setLayoutData(new GridData(SWT.LEFT, SWT.TOP, false, false, 1, 1)); |
| } |
| } |
| |
| private void updateResolvedLabel() { |
| if (mResourceResolver == null) { |
| return; |
| } |
| |
| String v = null; |
| if (mCurrentResource != null) { |
| v = mCurrentResource; |
| if (mCurrentResource.startsWith(PREFIX_RESOURCE_REF)) { |
| ResourceValue value = mResourceResolver.findResValue(mCurrentResource, false); |
| if (value != null) { |
| v = value.getValue(); |
| } |
| } |
| } |
| |
| if (v == null) { |
| v = ""; |
| } |
| |
| mResolvedLabel.setText(String.format("Resolved Value: %1$s", v)); |
| } |
| |
| @Override |
| protected void handleSelectionChanged() { |
| super.handleSelectionChanged(); |
| if (mInputValidator != null) { |
| Object[] elements = getSelectedElements(); |
| if (elements.length == 1 && elements[0] instanceof ResourceItem) { |
| ResourceItem item = (ResourceItem)elements[0]; |
| String current = item.getXmlString(mResourceType, mSystemButton.getSelection()); |
| String error = mInputValidator.isValid(current); |
| IStatus status; |
| if (error != null) { |
| status = new Status(IStatus.ERROR, AdtPlugin.PLUGIN_ID, error); |
| } else { |
| status = new Status(IStatus.OK, AdtPlugin.PLUGIN_ID, null); |
| } |
| updateStatus(status); |
| } |
| } |
| |
| updateValue(); |
| } |
| |
| private void updateValue() { |
| if (mPreviewHelper != null) { |
| computeResult(); |
| mPreviewHelper.updatePreview(mResourceType, mCurrentResource); |
| } |
| |
| if (mShowValueText) { |
| if (mFirstSelect) { |
| mFirstSelect = false; |
| mEditValueText.selectAll(); |
| } else { |
| computeResultFromSelection(); |
| mEditValueText.setText(mCurrentResource != null ? mCurrentResource : ""); |
| } |
| } |
| |
| if (mResourceResolver != null) { |
| if (!mShowValueText) { |
| computeResultFromSelection(); |
| } |
| updateResolvedLabel(); |
| } |
| } |
| |
| @Nullable |
| private String createNewFile(ResourceType type) { |
| // Show a name/value dialog entering the key name and the value |
| Shell shell = AdtPlugin.getShell(); |
| if (shell == null) { |
| return null; |
| } |
| |
| ResourceNameValidator validator = ResourceNameValidator.create(true /*allowXmlExtension*/, |
| mProject, mResourceType); |
| InputDialog d = new InputDialog( |
| AdtPlugin.getShell(), |
| "Enter name", // title |
| "Enter name", |
| "", //$NON-NLS-1$ |
| validator); |
| if (d.open() == Window.OK) { |
| String name = d.getValue().trim(); |
| if (name.length() == 0) { |
| return null; |
| } |
| |
| Pair<IFile, IRegion> resource = ResourceHelper.createResource(mProject, type, name, |
| null); |
| if (resource != null) { |
| return name; |
| } |
| } |
| |
| return null; |
| } |
| |
| |
| @Nullable |
| private String createNewValue(ResourceType type) { |
| // Show a name/value dialog entering the key name and the value |
| Shell shell = AdtPlugin.getShell(); |
| if (shell == null) { |
| return null; |
| } |
| NameValueDialog dialog = new NameValueDialog(shell, getFilter()); |
| if (dialog.open() != Window.OK) { |
| return null; |
| } |
| |
| String name = dialog.getName(); |
| String value = dialog.getValue(); |
| if (name.length() == 0 || value.length() == 0) { |
| return null; |
| } |
| |
| Pair<IFile, IRegion> resource = ResourceHelper.createResource(mProject, type, name, value); |
| if (resource != null) { |
| return name; |
| } |
| |
| return null; |
| } |
| |
| private String createNewString() { |
| ExtractStringRefactoring ref = new ExtractStringRefactoring( |
| mProject, true /*enforceNew*/); |
| RefactoringWizard wizard = new ExtractStringWizard(ref, mProject); |
| RefactoringWizardOpenOperation op = new RefactoringWizardOpenOperation(wizard); |
| try { |
| IWorkbench w = PlatformUI.getWorkbench(); |
| if (op.run(w.getDisplay().getActiveShell(), wizard.getDefaultPageTitle()) == |
| IDialogConstants.OK_ID) { |
| return ref.getXmlStringId(); |
| } |
| } catch (InterruptedException ex) { |
| // Interrupted. Pass. |
| } |
| |
| return null; |
| } |
| |
| /** |
| * Setups the current list. |
| */ |
| private ResourceItem[] setupResourceList() { |
| Collection<ResourceItem> items = null; |
| if (mProjectButton.getSelection()) { |
| if (mProjectResources.size() == 1) { |
| items = mProjectResources.get(0).getResourceItemsOfType(mResourceType); |
| } else { |
| Map<String, ResourceItem> merged = Maps.newHashMapWithExpectedSize(200); |
| for (ResourceRepository repository : mProjectResources) { |
| for (ResourceItem item : repository.getResourceItemsOfType(mResourceType)) { |
| if (!merged.containsKey(item.getName())) { |
| merged.put(item.getName(), item); |
| } |
| } |
| } |
| items = merged.values(); |
| } |
| } else if (mSystemButton.getSelection()) { |
| items = mFrameworkResources.getResourceItemsOfType(mResourceType); |
| } |
| |
| if (items == null) { |
| items = Collections.emptyList(); |
| } |
| |
| ResourceItem[] arrayItems = items.toArray(new ResourceItem[items.size()]); |
| |
| // sort the array |
| Arrays.sort(arrayItems); |
| |
| setListElements(arrayItems); |
| fFilteredList.setEnabled(arrayItems.length > 0); |
| |
| return arrayItems; |
| } |
| |
| /** |
| * Select an item by its name, if possible. |
| */ |
| private void selectItemName(String itemName, ResourceItem[] items) { |
| if (itemName == null || items == null) { |
| return; |
| } |
| |
| for (ResourceItem item : items) { |
| if (itemName.equals(item.getName())) { |
| setSelection(new Object[] { item }); |
| break; |
| } |
| } |
| } |
| |
| /** |
| * Select an item by its full resource string. |
| * This also selects between project and system repository based on the resource string. |
| */ |
| private void selectResourceString(String resourceString) { |
| boolean isSystem = false; |
| String itemName = null; |
| |
| if (resourceString != null) { |
| // Is this a system resource? |
| // If not a system resource or if they are not available, this will be a project res. |
| Matcher m = mSystemResourcePattern.matcher(resourceString); |
| if (m.matches()) { |
| itemName = m.group(1); |
| isSystem = true; |
| } |
| |
| if (!isSystem && itemName == null) { |
| // Try to match project resource name |
| m = mProjectResourcePattern.matcher(resourceString); |
| if (m.matches()) { |
| itemName = m.group(1); |
| } |
| } |
| } |
| |
| // Update the repository selection |
| mProjectButton.setSelection(!isSystem); |
| mSystemButton.setSelection(isSystem); |
| updateNewButton(isSystem); |
| |
| // Update the list |
| ResourceItem[] items = setupResourceList(); |
| |
| // If we have a selection name, select it |
| if (itemName != null) { |
| selectItemName(itemName, items); |
| } |
| } |
| |
| private void updateNewButton(boolean isSystem) { |
| mNewButton.setEnabled(!isSystem && ResourceHelper.canCreateResourceType(mResourceType)); |
| } |
| |
| // ---- Implements ModifyListener ---- |
| |
| @Override |
| public void modifyText(ModifyEvent e) { |
| if (e.getSource() == mEditValueText && mResourceResolver != null) { |
| mCurrentResource = mEditValueText.getText(); |
| |
| if (mCurrentResource.startsWith(PREFIX_RESOURCE_REF)) { |
| if (mProjectResourcePattern.matcher(mCurrentResource).matches() || |
| mSystemResourcePattern.matcher(mCurrentResource).matches()) { |
| updateResolvedLabel(); |
| } |
| } else { |
| updateResolvedLabel(); |
| } |
| } |
| } |
| |
| /** Dialog asking for a Name/Value pair */ |
| private class NameValueDialog extends SelectionStatusDialog implements Listener { |
| private org.eclipse.swt.widgets.Text mNameText; |
| private org.eclipse.swt.widgets.Text mValueText; |
| private String mInitialName; |
| private String mName; |
| private String mValue; |
| private ResourceNameValidator mValidator; |
| |
| public NameValueDialog(Shell parent, String initialName) { |
| super(parent); |
| mInitialName = initialName; |
| } |
| |
| @Override |
| protected Control createDialogArea(Composite parent) { |
| Composite container = new Composite(parent, SWT.NONE); |
| container.setLayout(new GridLayout(2, false)); |
| GridData gridData = new GridData(SWT.FILL, SWT.FILL, true, true, 1, 1); |
| // Wide enough to accommodate the error label |
| gridData.widthHint = 500; |
| container.setLayoutData(gridData); |
| |
| |
| Label nameLabel = new Label(container, SWT.NONE); |
| nameLabel.setLayoutData(new GridData(SWT.RIGHT, SWT.CENTER, false, false, 1, 1)); |
| nameLabel.setText("Name:"); |
| |
| mNameText = new org.eclipse.swt.widgets.Text(container, SWT.BORDER); |
| mNameText.setLayoutData(new GridData(SWT.FILL, SWT.CENTER, true, false, 1, 1)); |
| if (mInitialName != null) { |
| mNameText.setText(mInitialName); |
| mNameText.selectAll(); |
| } |
| |
| Label valueLabel = new Label(container, SWT.NONE); |
| valueLabel.setLayoutData(new GridData(SWT.RIGHT, SWT.CENTER, false, false, 1, 1)); |
| valueLabel.setText("Value:"); |
| |
| mValueText = new org.eclipse.swt.widgets.Text(container, SWT.BORDER); |
| mValueText.setLayoutData(new GridData(SWT.FILL, SWT.CENTER, true, false, 1, 1)); |
| |
| mNameText.addListener(SWT.Modify, this); |
| mValueText.addListener(SWT.Modify, this); |
| |
| validate(); |
| |
| return container; |
| } |
| |
| @Override |
| protected void computeResult() { |
| mName = mNameText.getText().trim(); |
| mValue = mValueText.getText().trim(); |
| } |
| |
| private String getName() { |
| return mName; |
| } |
| |
| private String getValue() { |
| return mValue; |
| } |
| |
| @Override |
| public void handleEvent(Event event) { |
| validate(); |
| } |
| |
| private void validate() { |
| IStatus status; |
| computeResult(); |
| if (mName.length() == 0) { |
| status = new Status(IStatus.ERROR, AdtPlugin.PLUGIN_ID, "Enter a name"); |
| } else if (mValue.length() == 0) { |
| status = new Status(IStatus.ERROR, AdtPlugin.PLUGIN_ID, "Enter a value"); |
| } else { |
| if (mValidator == null) { |
| mValidator = ResourceNameValidator.create(false, mProject, mResourceType); |
| } |
| String error = mValidator.isValid(mName); |
| if (error != null) { |
| status = new Status(IStatus.ERROR, AdtPlugin.PLUGIN_ID, error); |
| } else { |
| status = new Status(IStatus.OK, AdtPlugin.PLUGIN_ID, null); |
| } |
| } |
| updateStatus(status); |
| } |
| } |
| |
| /** |
| * Open the resource chooser for the given type, associated with the given |
| * editor |
| * |
| * @param graphicalEditor the editor associated with the resource to be |
| * chosen (used to find the associated Android target to be used |
| * for framework resources etc) |
| * @param type the resource type to be chosen |
| * @param currentValue the current value, or null |
| * @param validator a validator to be used, or null |
| * @return the chosen resource, null if cancelled and "" if value should be |
| * cleared |
| */ |
| public static String chooseResource( |
| @NonNull GraphicalEditorPart graphicalEditor, |
| @NonNull ResourceType type, |
| String currentValue, IInputValidator validator) { |
| ResourceChooser chooser = create(graphicalEditor, type). |
| setCurrentResource(currentValue); |
| if (validator != null) { |
| // Ensure wide enough to accommodate validator error message |
| chooser.setSize(85, 10); |
| chooser.setInputValidator(validator); |
| } |
| int result = chooser.open(); |
| if (result == ResourceChooser.CLEAR_RETURN_CODE) { |
| return ""; //$NON-NLS-1$ |
| } else if (result == Window.OK) { |
| return chooser.getCurrentResource(); |
| } |
| |
| return null; |
| } |
| } |
