Java tutorial
/* * 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; } }