| /* |
| * Copyright (C) 2008 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.wizards.newxmlfile; |
| |
| import static com.android.SdkConstants.DOT_XML; |
| import static com.android.SdkConstants.HORIZONTAL_SCROLL_VIEW; |
| import static com.android.SdkConstants.LINEAR_LAYOUT; |
| import static com.android.SdkConstants.RES_QUALIFIER_SEP; |
| import static com.android.SdkConstants.SCROLL_VIEW; |
| import static com.android.SdkConstants.VALUE_FILL_PARENT; |
| import static com.android.SdkConstants.VALUE_MATCH_PARENT; |
| import static com.android.ide.eclipse.adt.AdtConstants.WS_SEP_CHAR; |
| import static com.android.ide.eclipse.adt.internal.wizards.newxmlfile.ChooseConfigurationPage.RES_FOLDER_ABS; |
| |
| import com.android.SdkConstants; |
| import com.android.ide.common.resources.configuration.FolderConfiguration; |
| import com.android.ide.common.resources.configuration.ResourceQualifier; |
| import com.android.ide.eclipse.adt.AdtConstants; |
| import com.android.ide.eclipse.adt.AdtPlugin; |
| import com.android.ide.eclipse.adt.AdtUtils; |
| import com.android.ide.eclipse.adt.internal.editors.AndroidXmlEditor; |
| import com.android.ide.eclipse.adt.internal.editors.IconFactory; |
| import com.android.ide.eclipse.adt.internal.editors.descriptors.DocumentDescriptor; |
| 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.project.ProjectChooserHelper; |
| import com.android.ide.eclipse.adt.internal.project.ProjectChooserHelper.ProjectCombo; |
| import com.android.ide.eclipse.adt.internal.resources.ResourceNameValidator; |
| import com.android.ide.eclipse.adt.internal.sdk.AndroidTargetData; |
| import com.android.ide.eclipse.adt.internal.sdk.Sdk; |
| import com.android.ide.eclipse.adt.internal.sdk.Sdk.TargetChangeListener; |
| import com.android.resources.ResourceFolderType; |
| import com.android.sdklib.IAndroidTarget; |
| import com.android.utils.Pair; |
| import com.android.utils.SdkUtils; |
| |
| import org.eclipse.core.resources.IFile; |
| import org.eclipse.core.resources.IProject; |
| import org.eclipse.core.resources.IResource; |
| import org.eclipse.core.runtime.CoreException; |
| import org.eclipse.core.runtime.IAdaptable; |
| import org.eclipse.core.runtime.IPath; |
| import org.eclipse.core.runtime.IStatus; |
| import org.eclipse.jdt.core.IJavaProject; |
| import org.eclipse.jface.dialogs.IMessageProvider; |
| import org.eclipse.jface.viewers.ArrayContentProvider; |
| import org.eclipse.jface.viewers.ColumnLabelProvider; |
| import org.eclipse.jface.viewers.IBaseLabelProvider; |
| import org.eclipse.jface.viewers.IStructuredSelection; |
| import org.eclipse.jface.viewers.TableViewer; |
| import org.eclipse.jface.wizard.WizardPage; |
| 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.graphics.Image; |
| import org.eclipse.swt.layout.GridData; |
| import org.eclipse.swt.layout.GridLayout; |
| import org.eclipse.swt.widgets.Combo; |
| import org.eclipse.swt.widgets.Composite; |
| import org.eclipse.swt.widgets.Label; |
| import org.eclipse.swt.widgets.Table; |
| import org.eclipse.swt.widgets.Text; |
| import org.eclipse.ui.IEditorPart; |
| import org.eclipse.ui.IWorkbenchPage; |
| import org.eclipse.ui.IWorkbenchWindow; |
| import org.eclipse.ui.PlatformUI; |
| import org.eclipse.ui.part.FileEditorInput; |
| |
| import java.util.ArrayList; |
| import java.util.Collections; |
| import java.util.HashSet; |
| import java.util.List; |
| |
| /** |
| * This is the first page of the {@link NewXmlFileWizard} which provides the ability to create |
| * skeleton XML resources files for Android projects. |
| * <p/> |
| * This page is used to select the project, resource type and file name. |
| */ |
| class NewXmlFileCreationPage extends WizardPage { |
| |
| @Override |
| public void setVisible(boolean visible) { |
| super.setVisible(visible); |
| // Ensure the initial focus is in the Name field; you usually don't need |
| // to edit the default text field (the project name) |
| if (visible && mFileNameTextField != null) { |
| mFileNameTextField.setFocus(); |
| } |
| |
| validatePage(); |
| } |
| |
| /** |
| * Information on one type of resource that can be created (e.g. menu, pref, layout, etc.) |
| */ |
| static class TypeInfo { |
| private final String mUiName; |
| private final ResourceFolderType mResFolderType; |
| private final String mTooltip; |
| private final Object mRootSeed; |
| private ArrayList<String> mRoots = new ArrayList<String>(); |
| private final String mXmlns; |
| private final String mDefaultAttrs; |
| private final String mDefaultRoot; |
| private final int mTargetApiLevel; |
| |
| public TypeInfo(String uiName, |
| String tooltip, |
| ResourceFolderType resFolderType, |
| Object rootSeed, |
| String defaultRoot, |
| String xmlns, |
| String defaultAttrs, |
| int targetApiLevel) { |
| mUiName = uiName; |
| mResFolderType = resFolderType; |
| mTooltip = tooltip; |
| mRootSeed = rootSeed; |
| mDefaultRoot = defaultRoot; |
| mXmlns = xmlns; |
| mDefaultAttrs = defaultAttrs; |
| mTargetApiLevel = targetApiLevel; |
| } |
| |
| /** Returns the UI name for the resource type. Unique. Never null. */ |
| String getUiName() { |
| return mUiName; |
| } |
| |
| /** Returns the tooltip for the resource type. Can be null. */ |
| String getTooltip() { |
| return mTooltip; |
| } |
| |
| /** |
| * Returns the name of the {@link ResourceFolderType}. |
| * Never null but not necessarily unique, |
| * e.g. two types use {@link ResourceFolderType#XML}. |
| */ |
| String getResFolderName() { |
| return mResFolderType.getName(); |
| } |
| |
| /** |
| * Returns the matching {@link ResourceFolderType}. |
| * Never null but not necessarily unique, |
| * e.g. two types use {@link ResourceFolderType#XML}. |
| */ |
| ResourceFolderType getResFolderType() { |
| return mResFolderType; |
| } |
| |
| /** |
| * Returns the seed used to fill the root element values. |
| * The seed might be either a String, a String array, an {@link ElementDescriptor}, |
| * a {@link DocumentDescriptor} or null. |
| */ |
| Object getRootSeed() { |
| return mRootSeed; |
| } |
| |
| /** |
| * Returns the default root element that should be selected by default. Can be |
| * null. |
| * |
| * @param project the associated project, or null if not known |
| */ |
| String getDefaultRoot(IProject project) { |
| return mDefaultRoot; |
| } |
| |
| /** |
| * Returns the list of all possible root elements for the resource type. |
| * This can be an empty ArrayList but not null. |
| * <p/> |
| * TODO: the root list SHOULD depend on the currently selected project, to include |
| * custom classes. |
| */ |
| ArrayList<String> getRoots() { |
| return mRoots; |
| } |
| |
| /** |
| * If the generated resource XML file requires an "android" XMLNS, this should be set |
| * to {@link SdkConstants#NS_RESOURCES}. When it is null, no XMLNS is generated. |
| */ |
| String getXmlns() { |
| return mXmlns; |
| } |
| |
| /** |
| * When not null, this represent extra attributes that must be specified in the |
| * root element of the generated XML file. When null, no extra attributes are inserted. |
| * |
| * @param project the project to get the attributes for |
| * @param root the selected root element string, never null |
| */ |
| String getDefaultAttrs(IProject project, String root) { |
| return mDefaultAttrs; |
| } |
| |
| /** |
| * When not null, represents an extra string that should be written inside |
| * the element when constructed |
| * |
| * @param project the project to get the child content for |
| * @param root the chosen root element |
| * @return a string to be written inside the root element, or null if nothing |
| */ |
| String getChild(IProject project, String root) { |
| return null; |
| } |
| |
| /** |
| * The minimum API level required by the current SDK target to support this feature. |
| * |
| * @return the minimum API level |
| */ |
| public int getTargetApiLevel() { |
| return mTargetApiLevel; |
| } |
| } |
| |
| /** |
| * TypeInfo, information for each "type" of file that can be created. |
| */ |
| private static final TypeInfo[] sTypes = { |
| new TypeInfo( |
| "Layout", // UI name |
| "An XML file that describes a screen layout.", // tooltip |
| ResourceFolderType.LAYOUT, // folder type |
| AndroidTargetData.DESCRIPTOR_LAYOUT, // root seed |
| LINEAR_LAYOUT, // default root |
| SdkConstants.NS_RESOURCES, // xmlns |
| "", // not used, see below |
| 1 // target API level |
| ) { |
| |
| @Override |
| String getDefaultRoot(IProject project) { |
| // TODO: Use GridLayout by default for new SDKs |
| // (when we've ironed out all the usability issues) |
| //Sdk currentSdk = Sdk.getCurrent(); |
| //if (project != null && currentSdk != null) { |
| // IAndroidTarget target = currentSdk.getTarget(project); |
| // // fill_parent was renamed match_parent in API level 8 |
| // if (target != null && target.getVersion().getApiLevel() >= 13) { |
| // return GRID_LAYOUT; |
| // } |
| //} |
| |
| return LINEAR_LAYOUT; |
| }; |
| |
| // The default attributes must be determined dynamically since whether |
| // we use match_parent or fill_parent depends on the API level of the |
| // project |
| @Override |
| String getDefaultAttrs(IProject project, String root) { |
| Sdk currentSdk = Sdk.getCurrent(); |
| String fill = VALUE_FILL_PARENT; |
| if (currentSdk != null) { |
| IAndroidTarget target = currentSdk.getTarget(project); |
| // fill_parent was renamed match_parent in API level 8 |
| if (target != null && target.getVersion().getApiLevel() >= 8) { |
| fill = VALUE_MATCH_PARENT; |
| } |
| } |
| |
| // Only set "vertical" orientation of LinearLayouts by default; |
| // for GridLayouts for example we want to rely on the real default |
| // of the layout |
| String size = String.format( |
| "android:layout_width=\"%1$s\"\n" //$NON-NLS-1$ |
| + "android:layout_height=\"%2$s\"", //$NON-NLS-1$ |
| fill, fill); |
| if (LINEAR_LAYOUT.equals(root)) { |
| return "android:orientation=\"vertical\"\n" + size; //$NON-NLS-1$ |
| } else { |
| return size; |
| } |
| } |
| |
| @Override |
| String getChild(IProject project, String root) { |
| // Create vertical linear layouts inside new scroll views |
| if (SCROLL_VIEW.equals(root) || HORIZONTAL_SCROLL_VIEW.equals(root)) { |
| return " <LinearLayout " //$NON-NLS-1$ |
| + getDefaultAttrs(project, root).replace('\n', ' ') |
| + " android:orientation=\"vertical\"" //$NON-NLS-1$ |
| + "></LinearLayout>\n"; //$NON-NLS-1$ |
| } |
| return null; |
| } |
| }, |
| new TypeInfo("Values", // UI name |
| "An XML file with simple values: colors, strings, dimensions, etc.", // tooltip |
| ResourceFolderType.VALUES, // folder type |
| SdkConstants.TAG_RESOURCES, // root seed |
| null, // default root |
| null, // xmlns |
| null, // default attributes |
| 1 // target API level |
| ), |
| new TypeInfo("Drawable", // UI name |
| "An XML file that describes a drawable.", // tooltip |
| ResourceFolderType.DRAWABLE, // folder type |
| AndroidTargetData.DESCRIPTOR_DRAWABLE, // root seed |
| null, // default root |
| SdkConstants.NS_RESOURCES, // xmlns |
| null, // default attributes |
| 1 // target API level |
| ), |
| new TypeInfo("Menu", // UI name |
| "An XML file that describes an menu.", // tooltip |
| ResourceFolderType.MENU, // folder type |
| SdkConstants.TAG_MENU, // root seed |
| null, // default root |
| SdkConstants.NS_RESOURCES, // xmlns |
| null, // default attributes |
| 1 // target API level |
| ), |
| new TypeInfo("Color List", // UI name |
| "An XML file that describes a color state list.", // tooltip |
| ResourceFolderType.COLOR, // folder type |
| AndroidTargetData.DESCRIPTOR_COLOR, // root seed |
| "selector", //$NON-NLS-1$ // default root |
| SdkConstants.NS_RESOURCES, // xmlns |
| null, // default attributes |
| 1 // target API level |
| ), |
| new TypeInfo("Property Animation", // UI name |
| "An XML file that describes a property animation", // tooltip |
| ResourceFolderType.ANIMATOR, // folder type |
| AndroidTargetData.DESCRIPTOR_ANIMATOR, // root seed |
| "set", //$NON-NLS-1$ // default root |
| SdkConstants.NS_RESOURCES, // xmlns |
| null, // default attributes |
| 11 // target API level |
| ), |
| new TypeInfo("Tween Animation", // UI name |
| "An XML file that describes a tween animation.", // tooltip |
| ResourceFolderType.ANIM, // folder type |
| AndroidTargetData.DESCRIPTOR_ANIM, // root seed |
| "set", //$NON-NLS-1$ // default root |
| null, // xmlns |
| null, // default attributes |
| 1 // target API level |
| ), |
| new TypeInfo("AppWidget Provider", // UI name |
| "An XML file that describes a widget provider.", // tooltip |
| ResourceFolderType.XML, // folder type |
| AndroidTargetData.DESCRIPTOR_APPWIDGET_PROVIDER, // root seed |
| null, // default root |
| SdkConstants.NS_RESOURCES, // xmlns |
| null, // default attributes |
| 3 // target API level |
| ), |
| new TypeInfo("Preference", // UI name |
| "An XML file that describes preferences.", // tooltip |
| ResourceFolderType.XML, // folder type |
| AndroidTargetData.DESCRIPTOR_PREFERENCES, // root seed |
| SdkConstants.CLASS_NAME_PREFERENCE_SCREEN, // default root |
| SdkConstants.NS_RESOURCES, // xmlns |
| null, // default attributes |
| 1 // target API level |
| ), |
| new TypeInfo("Searchable", // UI name |
| "An XML file that describes a searchable.", // tooltip |
| ResourceFolderType.XML, // folder type |
| AndroidTargetData.DESCRIPTOR_SEARCHABLE, // root seed |
| null, // default root |
| SdkConstants.NS_RESOURCES, // xmlns |
| null, // default attributes |
| 1 // target API level |
| ), |
| // Still missing: Interpolator, Raw and Mipmap. Raw should probably never be in |
| // this menu since it's not often used for creating XML files. |
| }; |
| |
| private NewXmlFileWizard.Values mValues; |
| private ProjectCombo mProjectButton; |
| private Text mFileNameTextField; |
| private Combo mTypeCombo; |
| private IStructuredSelection mInitialSelection; |
| private ResourceFolderType mInitialFolderType; |
| private boolean mInternalTypeUpdate; |
| private TargetChangeListener mSdkTargetChangeListener; |
| private Table mRootTable; |
| private TableViewer mRootTableViewer; |
| |
| // --- UI creation --- |
| |
| /** |
| * Constructs a new {@link NewXmlFileCreationPage}. |
| * <p/> |
| * Called by {@link NewXmlFileWizard#createMainPage}. |
| */ |
| protected NewXmlFileCreationPage(String pageName, NewXmlFileWizard.Values values) { |
| super(pageName); |
| mValues = values; |
| setPageComplete(false); |
| } |
| |
| public void setInitialSelection(IStructuredSelection initialSelection) { |
| mInitialSelection = initialSelection; |
| } |
| |
| public void setInitialFolderType(ResourceFolderType initialType) { |
| mInitialFolderType = initialType; |
| } |
| |
| /** |
| * Called by the parent Wizard to create the UI for this Wizard Page. |
| * |
| * {@inheritDoc} |
| * |
| * @see org.eclipse.jface.dialogs.IDialogPage#createControl(org.eclipse.swt.widgets.Composite) |
| */ |
| @Override |
| @SuppressWarnings("unused") // SWT constructors have side effects, they aren't unused |
| public void createControl(Composite parent) { |
| // This UI is maintained with WindowBuilder. |
| |
| Composite composite = new Composite(parent, SWT.NULL); |
| composite.setLayout(new GridLayout(2, false /*makeColumnsEqualWidth*/)); |
| composite.setLayoutData(new GridData(GridData.FILL_BOTH)); |
| |
| // label before type radios |
| Label typeLabel = new Label(composite, SWT.NONE); |
| typeLabel.setText("Resource Type:"); |
| |
| mTypeCombo = new Combo(composite, SWT.DROP_DOWN | SWT.READ_ONLY); |
| mTypeCombo.setToolTipText("What type of resource would you like to create?"); |
| mTypeCombo.setLayoutData(new GridData(GridData.FILL_HORIZONTAL)); |
| if (mInitialFolderType != null) { |
| mTypeCombo.setEnabled(false); |
| } |
| mTypeCombo.addSelectionListener(new SelectionAdapter() { |
| @Override |
| public void widgetSelected(SelectionEvent e) { |
| TypeInfo type = getSelectedType(); |
| if (type != null) { |
| onSelectType(type); |
| } |
| } |
| }); |
| |
| // separator |
| Label separator = new Label(composite, SWT.SEPARATOR | SWT.HORIZONTAL); |
| GridData gd2 = new GridData(GridData.GRAB_HORIZONTAL); |
| gd2.horizontalAlignment = SWT.FILL; |
| gd2.horizontalSpan = 2; |
| separator.setLayoutData(gd2); |
| |
| // Project: [button] |
| String tooltip = "The Android Project where the new resource file will be created."; |
| Label projectLabel = new Label(composite, SWT.NONE); |
| projectLabel.setText("Project:"); |
| projectLabel.setToolTipText(tooltip); |
| |
| ProjectChooserHelper helper = |
| new ProjectChooserHelper(getShell(), null /* filter */); |
| |
| mProjectButton = new ProjectCombo(helper, composite, mValues.project); |
| mProjectButton.setToolTipText(tooltip); |
| mProjectButton.setLayoutData(new GridData(GridData.FILL_HORIZONTAL)); |
| mProjectButton.addSelectionListener(new SelectionAdapter() { |
| @Override |
| public void widgetSelected(SelectionEvent e) { |
| IProject project = mProjectButton.getSelectedProject(); |
| if (project != mValues.project) { |
| changeProject(project); |
| } |
| }; |
| }); |
| |
| // Filename: [text] |
| Label fileLabel = new Label(composite, SWT.NONE); |
| fileLabel.setText("File:"); |
| fileLabel.setToolTipText("The name of the resource file to create."); |
| |
| mFileNameTextField = new Text(composite, SWT.BORDER); |
| mFileNameTextField.setLayoutData(new GridData(GridData.FILL_HORIZONTAL)); |
| mFileNameTextField.setToolTipText(tooltip); |
| mFileNameTextField.addModifyListener(new ModifyListener() { |
| @Override |
| public void modifyText(ModifyEvent e) { |
| mValues.name = mFileNameTextField.getText(); |
| validatePage(); |
| } |
| }); |
| |
| // separator |
| Label rootSeparator = new Label(composite, SWT.SEPARATOR | SWT.HORIZONTAL); |
| GridData gd = new GridData(GridData.GRAB_HORIZONTAL); |
| gd.horizontalAlignment = SWT.FILL; |
| gd.horizontalSpan = 2; |
| rootSeparator.setLayoutData(gd); |
| |
| // Root Element: |
| // [TableViewer] |
| Label rootLabel = new Label(composite, SWT.NONE); |
| rootLabel.setText("Root Element:"); |
| new Label(composite, SWT.NONE); |
| |
| mRootTableViewer = new TableViewer(composite, SWT.BORDER | SWT.FULL_SELECTION); |
| mRootTable = mRootTableViewer.getTable(); |
| GridData tableGridData = new GridData(SWT.FILL, SWT.FILL, true, true, 2, 1); |
| tableGridData.heightHint = 200; |
| mRootTable.setLayoutData(tableGridData); |
| |
| setControl(composite); |
| |
| // Update state the first time |
| setErrorMessage(null); |
| setMessage(null); |
| |
| initializeFromSelection(mInitialSelection); |
| updateAvailableTypes(); |
| initializeFromFixedType(); |
| initializeRootValues(); |
| installTargetChangeListener(); |
| |
| initialSelectType(); |
| validatePage(); |
| } |
| |
| private void initialSelectType() { |
| TypeInfo[] types = (TypeInfo[]) mTypeCombo.getData(); |
| int typeIndex = getTypeComboIndex(mValues.type); |
| if (typeIndex == -1) { |
| typeIndex = 0; |
| } else { |
| assert mValues.type == types[typeIndex]; |
| } |
| mTypeCombo.select(typeIndex); |
| onSelectType(types[typeIndex]); |
| updateRootCombo(types[typeIndex]); |
| } |
| |
| private void installTargetChangeListener() { |
| mSdkTargetChangeListener = new TargetChangeListener() { |
| @Override |
| public IProject getProject() { |
| return mValues.project; |
| } |
| |
| @Override |
| public void reload() { |
| if (mValues.project != null) { |
| changeProject(mValues.project); |
| } |
| } |
| }; |
| |
| AdtPlugin.getDefault().addTargetListener(mSdkTargetChangeListener); |
| } |
| |
| @Override |
| public void dispose() { |
| |
| if (mSdkTargetChangeListener != null) { |
| AdtPlugin.getDefault().removeTargetListener(mSdkTargetChangeListener); |
| mSdkTargetChangeListener = null; |
| } |
| |
| super.dispose(); |
| } |
| |
| /** |
| * Returns the selected root element string, if any. |
| * |
| * @return The selected root element string or null. |
| */ |
| public String getRootElement() { |
| int index = mRootTable.getSelectionIndex(); |
| if (index >= 0) { |
| Object[] roots = (Object[]) mRootTableViewer.getInput(); |
| return roots[index].toString(); |
| } |
| return null; |
| } |
| |
| /** |
| * Called by {@link NewXmlFileWizard} to initialize the page with the selection |
| * received by the wizard -- typically the current user workbench selection. |
| * <p/> |
| * Things we expect to find out from the selection: |
| * <ul> |
| * <li>The project name, valid if it's an android nature.</li> |
| * <li>The current folder, valid if it's a folder under /res</li> |
| * <li>An existing filename, in which case the user will be asked whether to override it.</li> |
| * </ul> |
| * <p/> |
| * The selection can also be set to a {@link Pair} of {@link IProject} and a workspace |
| * resource path (where the resource path does not have to exist yet, such as res/anim/). |
| * |
| * @param selection The selection when the wizard was initiated. |
| */ |
| private boolean initializeFromSelection(IStructuredSelection selection) { |
| if (selection == null) { |
| return false; |
| } |
| |
| // Find the best match in the element list. In case there are multiple selected elements |
| // select the one that provides the most information and assign them a score, |
| // e.g. project=1 + folder=2 + file=4. |
| IProject targetProject = null; |
| String targetWsFolderPath = null; |
| String targetFileName = null; |
| int targetScore = 0; |
| for (Object element : selection.toList()) { |
| if (element instanceof IAdaptable) { |
| IResource res = (IResource) ((IAdaptable) element).getAdapter(IResource.class); |
| IProject project = res != null ? res.getProject() : null; |
| |
| // Is this an Android project? |
| try { |
| if (project == null || !project.hasNature(AdtConstants.NATURE_DEFAULT)) { |
| continue; |
| } |
| } catch (CoreException e) { |
| // checking the nature failed, ignore this resource |
| continue; |
| } |
| |
| int score = 1; // we have a valid project at least |
| |
| IPath wsFolderPath = null; |
| String fileName = null; |
| assert res != null; // Eclipse incorrectly thinks res could be null, so tell it no |
| if (res.getType() == IResource.FOLDER) { |
| wsFolderPath = res.getProjectRelativePath(); |
| } else if (res.getType() == IResource.FILE) { |
| if (SdkUtils.endsWithIgnoreCase(res.getName(), DOT_XML)) { |
| fileName = res.getName(); |
| } |
| wsFolderPath = res.getParent().getProjectRelativePath(); |
| } |
| |
| // Disregard this folder selection if it doesn't point to /res/something |
| if (wsFolderPath != null && |
| wsFolderPath.segmentCount() > 1 && |
| SdkConstants.FD_RESOURCES.equals(wsFolderPath.segment(0))) { |
| score += 2; |
| } else { |
| wsFolderPath = null; |
| fileName = null; |
| } |
| |
| score += fileName != null ? 4 : 0; |
| |
| if (score > targetScore) { |
| targetScore = score; |
| targetProject = project; |
| targetWsFolderPath = wsFolderPath != null ? wsFolderPath.toString() : null; |
| targetFileName = fileName; |
| } |
| } else if (element instanceof Pair<?,?>) { |
| // Pair of Project/String |
| @SuppressWarnings("unchecked") |
| Pair<IProject,String> pair = (Pair<IProject,String>)element; |
| targetScore = 1; |
| targetProject = pair.getFirst(); |
| targetWsFolderPath = pair.getSecond(); |
| targetFileName = ""; |
| } |
| } |
| |
| if (targetProject == null) { |
| // Try to figure out the project from the active editor |
| IWorkbenchWindow window = PlatformUI.getWorkbench().getActiveWorkbenchWindow(); |
| if (window != null) { |
| IWorkbenchPage page = window.getActivePage(); |
| if (page != null) { |
| IEditorPart activeEditor = page.getActiveEditor(); |
| if (activeEditor instanceof AndroidXmlEditor) { |
| Object input = ((AndroidXmlEditor) activeEditor).getEditorInput(); |
| if (input instanceof FileEditorInput) { |
| FileEditorInput fileInput = (FileEditorInput) input; |
| targetScore = 1; |
| IFile file = fileInput.getFile(); |
| targetProject = file.getProject(); |
| IPath path = file.getParent().getProjectRelativePath(); |
| targetWsFolderPath = path != null ? path.toString() : null; |
| } |
| } |
| } |
| } |
| } |
| |
| if (targetProject == null) { |
| // If we didn't find a default project based on the selection, check how many |
| // open Android projects we can find in the current workspace. If there's only |
| // one, we'll just select it by default. |
| IJavaProject[] projects = AdtUtils.getOpenAndroidProjects(); |
| if (projects != null && projects.length == 1) { |
| targetScore = 1; |
| targetProject = projects[0].getProject(); |
| } |
| } |
| |
| // Now set the UI accordingly |
| if (targetScore > 0) { |
| mValues.project = targetProject; |
| mValues.folderPath = targetWsFolderPath; |
| mProjectButton.setSelectedProject(targetProject); |
| mFileNameTextField.setText(targetFileName != null ? targetFileName : ""); //$NON-NLS-1$ |
| |
| // If the current selection context corresponds to a specific file type, |
| // select it. |
| if (targetWsFolderPath != null) { |
| int pos = targetWsFolderPath.lastIndexOf(WS_SEP_CHAR); |
| if (pos >= 0) { |
| targetWsFolderPath = targetWsFolderPath.substring(pos + 1); |
| } |
| String[] folderSegments = targetWsFolderPath.split(RES_QUALIFIER_SEP); |
| if (folderSegments.length > 0) { |
| mValues.configuration = FolderConfiguration.getConfig(folderSegments); |
| String folderName = folderSegments[0]; |
| selectTypeFromFolder(folderName); |
| } |
| } |
| } |
| |
| return true; |
| } |
| |
| private void initializeFromFixedType() { |
| if (mInitialFolderType != null) { |
| for (TypeInfo type : sTypes) { |
| if (type.getResFolderType() == mInitialFolderType) { |
| mValues.type = type; |
| updateFolderPath(type); |
| break; |
| } |
| } |
| } |
| } |
| |
| /** |
| * Given a folder name, such as "drawable", select the corresponding type in |
| * the dropdown. |
| */ |
| void selectTypeFromFolder(String folderName) { |
| List<TypeInfo> matches = new ArrayList<TypeInfo>(); |
| boolean selected = false; |
| |
| TypeInfo selectedType = getSelectedType(); |
| for (TypeInfo type : sTypes) { |
| if (type.getResFolderName().equals(folderName)) { |
| matches.add(type); |
| selected |= type == selectedType; |
| } |
| } |
| |
| if (matches.size() == 1) { |
| // If there's only one match, select it if it's not already selected |
| if (!selected) { |
| selectType(matches.get(0)); |
| } |
| } else if (matches.size() > 1) { |
| // There are multiple type candidates for this folder. This can happen |
| // for /res/xml for example. Check to see if one of them is currently |
| // selected. If yes, leave the selection unchanged. If not, deselect all type. |
| if (!selected) { |
| selectType(null); |
| } |
| } else { |
| // Nothing valid was selected. |
| selectType(null); |
| } |
| } |
| |
| /** |
| * Initialize the root values of the type infos based on the current framework values. |
| */ |
| private void initializeRootValues() { |
| IProject project = mValues.project; |
| for (TypeInfo type : sTypes) { |
| // Clear all the roots for this type |
| ArrayList<String> roots = type.getRoots(); |
| if (roots.size() > 0) { |
| roots.clear(); |
| } |
| |
| // depending of the type of the seed, initialize the root in different ways |
| Object rootSeed = type.getRootSeed(); |
| |
| if (rootSeed instanceof String) { |
| // The seed is a single string, Add it as-is. |
| roots.add((String) rootSeed); |
| } else if (rootSeed instanceof String[]) { |
| // The seed is an array of strings. Add them as-is. |
| for (String value : (String[]) rootSeed) { |
| roots.add(value); |
| } |
| } else if (rootSeed instanceof Integer && project != null) { |
| // The seed is a descriptor reference defined in AndroidTargetData.DESCRIPTOR_* |
| // In this case add all the children element descriptors defined, recursively, |
| // and avoid infinite recursion by keeping track of what has already been added. |
| |
| // Note: if project is null, the root list will be empty since it has been |
| // cleared above. |
| |
| // get the AndroidTargetData from the project |
| IAndroidTarget target = null; |
| AndroidTargetData data = null; |
| |
| target = Sdk.getCurrent().getTarget(project); |
| if (target == null) { |
| // A project should have a target. The target can be missing if the project |
| // is an old project for which a target hasn't been affected or if the |
| // target no longer exists in this SDK. Simply log the error and dismiss. |
| |
| AdtPlugin.log(IStatus.INFO, |
| "NewXmlFile wizard: no platform target for project %s", //$NON-NLS-1$ |
| project.getName()); |
| continue; |
| } else { |
| data = Sdk.getCurrent().getTargetData(target); |
| |
| if (data == null) { |
| // We should have both a target and its data. |
| // However if the wizard is invoked whilst the platform is still being |
| // loaded we can end up in a weird case where we have a target but it |
| // doesn't have any data yet. |
| // Lets log a warning and silently ignore this root. |
| |
| AdtPlugin.log(IStatus.INFO, |
| "NewXmlFile wizard: no data for target %s, project %s", //$NON-NLS-1$ |
| target.getName(), project.getName()); |
| continue; |
| } |
| } |
| |
| IDescriptorProvider provider = data.getDescriptorProvider((Integer)rootSeed); |
| ElementDescriptor descriptor = provider.getDescriptor(); |
| if (descriptor != null) { |
| HashSet<ElementDescriptor> visited = new HashSet<ElementDescriptor>(); |
| initRootElementDescriptor(roots, descriptor, visited); |
| } |
| |
| // Sort alphabetically. |
| Collections.sort(roots); |
| } |
| } |
| } |
| |
| /** |
| * Helper method to recursively insert all XML names for the given {@link ElementDescriptor} |
| * into the roots array list. Keeps track of visited nodes to avoid infinite recursion. |
| * Also avoids inserting the top {@link DocumentDescriptor} which is generally synthetic |
| * and not a valid root element. |
| */ |
| private void initRootElementDescriptor(ArrayList<String> roots, |
| ElementDescriptor desc, HashSet<ElementDescriptor> visited) { |
| if (!(desc instanceof DocumentDescriptor)) { |
| String xmlName = desc.getXmlName(); |
| if (xmlName != null && xmlName.length() > 0) { |
| roots.add(xmlName); |
| } |
| } |
| |
| visited.add(desc); |
| |
| for (ElementDescriptor child : desc.getChildren()) { |
| if (!visited.contains(child)) { |
| initRootElementDescriptor(roots, child, visited); |
| } |
| } |
| } |
| |
| /** |
| * Changes mProject to the given new project and update the UI accordingly. |
| * <p/> |
| * Note that this does not check if the new project is the same as the current one |
| * on purpose, which allows a project to be updated when its target has changed or |
| * when targets are loaded in the background. |
| */ |
| private void changeProject(IProject newProject) { |
| mValues.project = newProject; |
| |
| // enable types based on new API level |
| updateAvailableTypes(); |
| initialSelectType(); |
| |
| // update the folder name based on API level |
| updateFolderPath(mValues.type); |
| |
| // update the Type with the new descriptors. |
| initializeRootValues(); |
| |
| // update the combo |
| updateRootCombo(mValues.type); |
| |
| validatePage(); |
| } |
| |
| private void onSelectType(TypeInfo type) { |
| // Do nothing if this is an internal modification or if the widget has been |
| // deselected. |
| if (mInternalTypeUpdate) { |
| return; |
| } |
| |
| mValues.type = type; |
| |
| if (type == null) { |
| return; |
| } |
| |
| // update the combo |
| updateRootCombo(type); |
| |
| // update the folder path |
| updateFolderPath(type); |
| |
| validatePage(); |
| } |
| |
| /** Updates the selected type in the type dropdown control */ |
| private void setSelectedType(TypeInfo type) { |
| TypeInfo[] types = (TypeInfo[]) mTypeCombo.getData(); |
| if (types != null) { |
| for (int i = 0, n = types.length; i < n; i++) { |
| if (types[i] == type) { |
| mTypeCombo.select(i); |
| break; |
| } |
| } |
| } |
| } |
| |
| /** Returns the selected type in the type dropdown control */ |
| private TypeInfo getSelectedType() { |
| int index = mTypeCombo.getSelectionIndex(); |
| if (index != -1) { |
| TypeInfo[] types = (TypeInfo[]) mTypeCombo.getData(); |
| return types[index]; |
| } |
| |
| return null; |
| } |
| |
| /** Returns the selected index in the type dropdown control */ |
| private int getTypeComboIndex(TypeInfo type) { |
| TypeInfo[] types = (TypeInfo[]) mTypeCombo.getData(); |
| for (int i = 0, n = types.length; i < n; i++) { |
| if (type == types[i]) { |
| return i; |
| } |
| } |
| |
| return -1; |
| } |
| |
| /** Updates the folder path to reflect the given type */ |
| private void updateFolderPath(TypeInfo type) { |
| String wsFolderPath = mValues.folderPath; |
| String newPath = null; |
| FolderConfiguration config = mValues.configuration; |
| ResourceQualifier qual = config.getInvalidQualifier(); |
| if (qual == null) { |
| // The configuration is valid. Reformat the folder path using the canonical |
| // value from the configuration. |
| newPath = RES_FOLDER_ABS + config.getFolderName(type.getResFolderType()); |
| } else { |
| // The configuration is invalid. We still update the path but this time |
| // do it manually on the string. |
| if (wsFolderPath.startsWith(RES_FOLDER_ABS)) { |
| wsFolderPath = wsFolderPath.replaceFirst( |
| "^(" + RES_FOLDER_ABS +")[^-]*(.*)", //$NON-NLS-1$ //$NON-NLS-2$ |
| "\\1" + type.getResFolderName() + "\\2"); //$NON-NLS-1$ //$NON-NLS-2$ |
| } else { |
| newPath = RES_FOLDER_ABS + config.getFolderName(type.getResFolderType()); |
| } |
| } |
| |
| if (newPath != null && !newPath.equals(wsFolderPath)) { |
| mValues.folderPath = newPath; |
| } |
| } |
| |
| /** |
| * Helper method that fills the values of the "root element" combo box based |
| * on the currently selected type radio button. Also disables the combo is there's |
| * only one choice. Always select the first root element for the given type. |
| * |
| * @param type The currently selected {@link TypeInfo}, or null |
| */ |
| private void updateRootCombo(TypeInfo type) { |
| IBaseLabelProvider labelProvider = new ColumnLabelProvider() { |
| @Override |
| public Image getImage(Object element) { |
| return IconFactory.getInstance().getIcon(element.toString()); |
| } |
| }; |
| mRootTableViewer.setContentProvider(new ArrayContentProvider()); |
| mRootTableViewer.setLabelProvider(labelProvider); |
| |
| if (type != null) { |
| // get the list of roots. The list can be empty but not null. |
| ArrayList<String> roots = type.getRoots(); |
| mRootTableViewer.setInput(roots.toArray()); |
| |
| int index = 0; // default is to select the first one |
| String defaultRoot = type.getDefaultRoot(mValues.project); |
| if (defaultRoot != null) { |
| index = roots.indexOf(defaultRoot); |
| } |
| mRootTable.select(index < 0 ? 0 : index); |
| mRootTable.showSelection(); |
| } |
| } |
| |
| /** |
| * Helper method to select the current type in the type dropdown |
| * |
| * @param type The TypeInfo matching the radio button to selected or null to deselect them all. |
| */ |
| private void selectType(TypeInfo type) { |
| mInternalTypeUpdate = true; |
| mValues.type = type; |
| if (type == null) { |
| if (mTypeCombo.getSelectionIndex() != -1) { |
| mTypeCombo.deselect(mTypeCombo.getSelectionIndex()); |
| } |
| } else { |
| setSelectedType(type); |
| } |
| updateRootCombo(type); |
| mInternalTypeUpdate = false; |
| } |
| |
| /** |
| * Add the available types in the type combobox, based on whether they are available |
| * for the current SDK. |
| * <p/> |
| * A type is available either if: |
| * - if mProject is null, API level 1 is considered valid |
| * - if mProject is !null, the project->target->API must be >= to the type's API level. |
| */ |
| private void updateAvailableTypes() { |
| IProject project = mValues.project; |
| IAndroidTarget target = project != null ? Sdk.getCurrent().getTarget(project) : null; |
| int currentApiLevel = 1; |
| if (target != null) { |
| currentApiLevel = target.getVersion().getApiLevel(); |
| } |
| |
| List<String> items = new ArrayList<String>(sTypes.length); |
| List<TypeInfo> types = new ArrayList<TypeInfo>(sTypes.length); |
| for (int i = 0, n = sTypes.length; i < n; i++) { |
| TypeInfo type = sTypes[i]; |
| if (type.getTargetApiLevel() <= currentApiLevel) { |
| items.add(type.getUiName()); |
| types.add(type); |
| } |
| } |
| mTypeCombo.setItems(items.toArray(new String[items.size()])); |
| mTypeCombo.setData(types.toArray(new TypeInfo[types.size()])); |
| } |
| |
| /** |
| * Validates the fields, displays errors and warnings. |
| * Enables the finish button if there are no errors. |
| */ |
| private void validatePage() { |
| String error = null; |
| String warning = null; |
| |
| // -- validate type |
| TypeInfo type = mValues.type; |
| if (error == null) { |
| if (type == null) { |
| error = "One of the types must be selected (e.g. layout, values, etc.)"; |
| } |
| } |
| |
| // -- validate project |
| if (mValues.project == null) { |
| error = "Please select an Android project."; |
| } |
| |
| // -- validate type API level |
| if (error == null) { |
| IAndroidTarget target = Sdk.getCurrent().getTarget(mValues.project); |
| int currentApiLevel = 1; |
| if (target != null) { |
| currentApiLevel = target.getVersion().getApiLevel(); |
| } |
| |
| assert type != null; |
| if (type.getTargetApiLevel() > currentApiLevel) { |
| error = "The API level of the selected type (e.g. AppWidget, etc.) is not " + |
| "compatible with the API level of the project."; |
| } |
| } |
| |
| // -- validate filename |
| if (error == null) { |
| String fileName = mValues.getFileName(); |
| assert type != null; |
| ResourceFolderType folderType = type.getResFolderType(); |
| error = ResourceNameValidator.create(true, folderType).isValid(fileName); |
| } |
| |
| // -- validate destination file doesn't exist |
| if (error == null) { |
| IFile file = mValues.getDestinationFile(); |
| if (file != null && file.exists()) { |
| warning = "The destination file already exists"; |
| } |
| } |
| |
| // -- update UI & enable finish if there's no error |
| setPageComplete(error == null); |
| if (error != null) { |
| setMessage(error, IMessageProvider.ERROR); |
| } else if (warning != null) { |
| setMessage(warning, IMessageProvider.WARNING); |
| } else { |
| setErrorMessage(null); |
| setMessage(null); |
| } |
| } |
| |
| /** |
| * Returns the {@link TypeInfo} for the given {@link ResourceFolderType}, or null if |
| * not found |
| * |
| * @param folderType the {@link ResourceFolderType} to look for |
| * @return the corresponding {@link TypeInfo} |
| */ |
| static TypeInfo getTypeInfo(ResourceFolderType folderType) { |
| for (TypeInfo typeInfo : sTypes) { |
| if (typeInfo.getResFolderType() == folderType) { |
| return typeInfo; |
| } |
| } |
| |
| return null; |
| } |
| } |
