| /* |
| * Copyright (C) 2012 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.templates; |
| |
| import static com.android.SdkConstants.CLASS_ACTIVITY; |
| import static com.android.ide.eclipse.adt.internal.wizards.templates.NewProjectWizard.ATTR_MIN_API; |
| import static com.android.ide.eclipse.adt.internal.wizards.templates.NewProjectWizard.ATTR_MIN_BUILD_API; |
| import static com.android.ide.eclipse.adt.internal.wizards.templates.TemplateHandler.ATTR_DEFAULT; |
| import static com.android.ide.eclipse.adt.internal.wizards.templates.TemplateHandler.ATTR_ID; |
| import static com.android.ide.eclipse.adt.internal.wizards.templates.TemplateHandler.ATTR_NAME; |
| import static com.android.ide.eclipse.adt.internal.wizards.templates.TemplateHandler.PREVIEW_PADDING; |
| import static com.android.ide.eclipse.adt.internal.wizards.templates.TemplateHandler.PREVIEW_WIDTH; |
| |
| import com.android.annotations.NonNull; |
| import com.android.annotations.Nullable; |
| import com.android.ide.eclipse.adt.AdtPlugin; |
| import com.android.ide.eclipse.adt.internal.editors.IconFactory; |
| import com.android.ide.eclipse.adt.internal.editors.layout.gle2.ImageControl; |
| import com.android.ide.eclipse.adt.internal.project.BaseProjectHelper; |
| 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.wizards.templates.Parameter.Constraint; |
| import com.android.ide.eclipse.adt.internal.wizards.templates.Parameter.Type; |
| import com.android.tools.lint.detector.api.LintUtils; |
| import com.google.common.collect.Lists; |
| |
| import org.eclipse.core.resources.IProject; |
| import org.eclipse.core.runtime.CoreException; |
| import org.eclipse.core.runtime.IStatus; |
| import org.eclipse.core.runtime.NullProgressMonitor; |
| import org.eclipse.core.runtime.Status; |
| import org.eclipse.jdt.core.Flags; |
| import org.eclipse.jdt.core.IJavaProject; |
| import org.eclipse.jdt.core.IType; |
| import org.eclipse.jdt.core.ITypeHierarchy; |
| import org.eclipse.jdt.core.JavaModelException; |
| import org.eclipse.jdt.core.search.IJavaSearchScope; |
| import org.eclipse.jdt.core.search.SearchEngine; |
| import org.eclipse.jdt.ui.IJavaElementSearchConstants; |
| import org.eclipse.jdt.ui.JavaUI; |
| import org.eclipse.jdt.ui.dialogs.ITypeInfoFilterExtension; |
| import org.eclipse.jdt.ui.dialogs.ITypeInfoRequestor; |
| import org.eclipse.jdt.ui.dialogs.TypeSelectionExtension; |
| import org.eclipse.jface.dialogs.IDialogConstants; |
| import org.eclipse.jface.dialogs.IInputValidator; |
| import org.eclipse.jface.dialogs.IMessageProvider; |
| import org.eclipse.jface.dialogs.ProgressMonitorDialog; |
| import org.eclipse.jface.fieldassist.ControlDecoration; |
| import org.eclipse.jface.fieldassist.FieldDecoration; |
| import org.eclipse.jface.fieldassist.FieldDecorationRegistry; |
| import org.eclipse.jface.wizard.WizardPage; |
| import org.eclipse.swt.SWT; |
| import org.eclipse.swt.events.FocusEvent; |
| import org.eclipse.swt.events.FocusListener; |
| import org.eclipse.swt.events.ModifyEvent; |
| import org.eclipse.swt.events.ModifyListener; |
| import org.eclipse.swt.events.SelectionEvent; |
| import org.eclipse.swt.events.SelectionListener; |
| import org.eclipse.swt.graphics.Image; |
| import org.eclipse.swt.layout.GridData; |
| import org.eclipse.swt.layout.GridLayout; |
| import org.eclipse.swt.widgets.Button; |
| import org.eclipse.swt.widgets.Combo; |
| import org.eclipse.swt.widgets.Composite; |
| import org.eclipse.swt.widgets.Control; |
| import org.eclipse.swt.widgets.Label; |
| import org.eclipse.swt.widgets.Shell; |
| import org.eclipse.swt.widgets.Text; |
| import org.eclipse.ui.dialogs.SelectionDialog; |
| import org.w3c.dom.Element; |
| import org.w3c.dom.Node; |
| import org.w3c.dom.NodeList; |
| |
| import java.io.ByteArrayInputStream; |
| import java.util.HashMap; |
| import java.util.HashSet; |
| import java.util.List; |
| import java.util.Map; |
| import java.util.Set; |
| |
| /** |
| * First wizard page in the "New Project From Template" wizard (which is parameterized |
| * via template.xml files) |
| */ |
| public class NewTemplatePage extends WizardPage |
| implements ModifyListener, SelectionListener, FocusListener { |
| /** The default width to use for the wizard page */ |
| static final int WIZARD_PAGE_WIDTH = 600; |
| |
| private final NewTemplateWizardState mValues; |
| private final boolean mChooseProject; |
| private int mCustomMinSdk = -1; |
| private int mCustomBuildApi = -1; |
| private boolean mIgnore; |
| private boolean mShown; |
| private Control mFirst; |
| // TODO: Move decorators to the Parameter objects? |
| private Map<String, ControlDecoration> mDecorations = new HashMap<String, ControlDecoration>(); |
| private Label mHelpIcon; |
| private Label mTipLabel; |
| private ImageControl mPreview; |
| private Image mPreviewImage; |
| private boolean mDisposePreviewImage; |
| private ProjectCombo mProjectButton; |
| private StringEvaluator mEvaluator; |
| |
| private TemplateMetadata mShowingTemplate; |
| |
| /** |
| * Creates a new {@link NewTemplatePage} |
| * |
| * @param values the wizard state |
| * @param chooseProject whether the wizard should present a project chooser, |
| * and update {@code values}' project field |
| */ |
| NewTemplatePage(NewTemplateWizardState values, boolean chooseProject) { |
| super("newTemplatePage"); //$NON-NLS-1$ |
| mValues = values; |
| mChooseProject = chooseProject; |
| } |
| |
| /** |
| * @param minSdk a minimum SDK to use, provided chooseProject is false. If |
| * it is true, then the minimum SDK used for validation will be |
| * the one of the project |
| * @param buildApi the build API to use |
| */ |
| void setCustomMinSdk(int minSdk, int buildApi) { |
| assert !mChooseProject; |
| //assert buildApi >= minSdk; |
| mCustomMinSdk = minSdk; |
| mCustomBuildApi = buildApi; |
| } |
| |
| @Override |
| public void createControl(Composite parent2) { |
| Composite parent = new Composite(parent2, SWT.NULL); |
| setControl(parent); |
| GridLayout parentLayout = new GridLayout(3, false); |
| parentLayout.verticalSpacing = 0; |
| parentLayout.marginWidth = 0; |
| parentLayout.marginHeight = 0; |
| parentLayout.horizontalSpacing = 0; |
| parent.setLayout(parentLayout); |
| |
| // Reserve enough width (since the panel is created lazily later) |
| Label label = new Label(parent, SWT.NONE); |
| GridData data = new GridData(); |
| data.widthHint = WIZARD_PAGE_WIDTH; |
| label.setLayoutData(data); |
| } |
| |
| @SuppressWarnings("unused") // SWT constructors have side effects and aren't unused |
| private void onEnter() { |
| TemplateMetadata template = mValues.getTemplateHandler().getTemplate(); |
| if (template == mShowingTemplate) { |
| return; |
| } |
| mShowingTemplate = template; |
| |
| Composite parent = (Composite) getControl(); |
| |
| Control[] children = parent.getChildren(); |
| if (children.length > 0) { |
| for (Control c : parent.getChildren()) { |
| c.dispose(); |
| } |
| for (ControlDecoration decoration : mDecorations.values()) { |
| decoration.dispose(); |
| } |
| mDecorations.clear(); |
| } |
| |
| Composite container = new Composite(parent, SWT.NULL); |
| container.setLayoutData(new GridData(SWT.FILL, SWT.CENTER, true, false, 2, 1)); |
| GridLayout gl_container = new GridLayout(3, false); |
| gl_container.horizontalSpacing = 10; |
| container.setLayout(gl_container); |
| |
| if (mChooseProject) { |
| // Project: [button] |
| String tooltip = "The Android Project where the new resource will be created."; |
| Label projectLabel = new Label(container, SWT.NONE); |
| projectLabel.setLayoutData(new GridData(SWT.RIGHT, SWT.CENTER, false, false, 1, 1)); |
| projectLabel.setText("Project:"); |
| projectLabel.setToolTipText(tooltip); |
| |
| ProjectChooserHelper helper = |
| new ProjectChooserHelper(getShell(), null /* filter */); |
| mProjectButton = new ProjectCombo(helper, container, mValues.project); |
| mProjectButton.setLayoutData(new GridData(SWT.FILL, SWT.CENTER, true, false, 2, 1)); |
| mProjectButton.setToolTipText(tooltip); |
| mProjectButton.addSelectionListener(this); |
| |
| //Label projectSeparator = new Label(container, SWT.SEPARATOR | SWT.HORIZONTAL); |
| //projectSeparator.setLayoutData(new GridData(SWT.FILL, SWT.TOP, true, false, 3, 1)); |
| } |
| |
| // Add parameters |
| mFirst = null; |
| String thumb = null; |
| if (template != null) { |
| thumb = template.getThumbnailPath(); |
| String title = template.getTitle(); |
| if (title != null && !title.isEmpty()) { |
| setTitle(title); |
| } |
| String description = template.getDescription(); |
| if (description != null && !description.isEmpty()) { |
| setDescription(description); |
| } |
| |
| Map<String, String> defaults = mValues.defaults; |
| Set<String> seen = null; |
| if (LintUtils.assertionsEnabled()) { |
| seen = new HashSet<String>(); |
| } |
| |
| List<Parameter> parameters = template.getParameters(); |
| for (Parameter parameter : parameters) { |
| Parameter.Type type = parameter.type; |
| |
| if (type == Parameter.Type.SEPARATOR) { |
| Label separator = new Label(container, SWT.SEPARATOR | SWT.HORIZONTAL); |
| separator.setLayoutData(new GridData(SWT.FILL, SWT.TOP, true, false, 3, 1)); |
| continue; |
| } |
| |
| String id = parameter.id; |
| assert id != null && !id.isEmpty() : ATTR_ID; |
| Object value = defaults.get(id); |
| if (value == null) { |
| value = parameter.value; |
| } |
| |
| String name = parameter.name; |
| String help = parameter.help; |
| |
| // Required |
| assert name != null && !name.isEmpty() : ATTR_NAME; |
| // Ensure id's are unique: |
| assert seen != null && seen.add(id) : id; |
| |
| // Skip attributes that were already provided by the surrounding |
| // context. For example, when adding into an existing project, |
| // provide the minimum SDK automatically from the project. |
| if (mValues.hidden != null && mValues.hidden.contains(id)) { |
| continue; |
| } |
| |
| switch (type) { |
| case STRING: { |
| // TODO: Look at the constraints to add validators here |
| // TODO: If I type.equals("layout") add resource validator for layout |
| // names |
| // TODO: If I type.equals("class") make class validator |
| |
| // TODO: Handle package and id better later |
| Label label = new Label(container, SWT.NONE); |
| label.setLayoutData(new GridData(SWT.RIGHT, SWT.CENTER, false, false, |
| 1, 1)); |
| label.setText(name); |
| |
| Text text = new Text(container, SWT.BORDER); |
| text.setData(parameter); |
| parameter.control = text; |
| |
| if (parameter.constraints.contains(Constraint.EXISTS)) { |
| text.setLayoutData(new GridData(SWT.FILL, SWT.CENTER, true, false, |
| 1, 1)); |
| |
| Button button = new Button(container, SWT.FLAT); |
| button.setData(parameter); |
| button.setText("..."); |
| button.addSelectionListener(this); |
| } else { |
| text.setLayoutData(new GridData(SWT.FILL, SWT.CENTER, true, false, |
| 2, 1)); |
| } |
| |
| boolean hasValue = false; |
| if (value instanceof String) { |
| String stringValue = (String) value; |
| hasValue = !stringValue.isEmpty(); |
| text.setText(stringValue); |
| mValues.parameters.put(id, value); |
| } |
| |
| if (!hasValue) { |
| if (parameter.constraints.contains(Constraint.EMPTY)) { |
| text.setMessage("Optional"); |
| } else if (parameter.constraints.contains(Constraint.NONEMPTY)) { |
| text.setMessage("Required"); |
| } |
| } |
| |
| text.addModifyListener(this); |
| text.addFocusListener(this); |
| |
| if (mFirst == null) { |
| mFirst = text; |
| } |
| |
| if (help != null && !help.isEmpty()) { |
| text.setToolTipText(help); |
| ControlDecoration decoration = createFieldDecoration(id, text, help); |
| } |
| break; |
| } |
| case BOOLEAN: { |
| Label label = new Label(container, SWT.NONE); |
| label.setLayoutData(new GridData(SWT.RIGHT, SWT.CENTER, false, false, |
| 1, 1)); |
| |
| Button checkBox = new Button(container, SWT.CHECK); |
| checkBox.setText(name); |
| checkBox.setData(parameter); |
| parameter.control = checkBox; |
| checkBox.setLayoutData(new GridData(SWT.FILL, SWT.CENTER, true, false, |
| 2, 1)); |
| |
| if (value instanceof Boolean) { |
| Boolean selected = (Boolean) value; |
| checkBox.setSelection(selected); |
| mValues.parameters.put(id, value); |
| } |
| |
| checkBox.addSelectionListener(this); |
| checkBox.addFocusListener(this); |
| |
| if (mFirst == null) { |
| mFirst = checkBox; |
| } |
| |
| if (help != null && !help.isEmpty()) { |
| checkBox.setToolTipText(help); |
| ControlDecoration decoration = createFieldDecoration(id, checkBox, |
| help); |
| } |
| break; |
| } |
| case ENUM: { |
| Label label = new Label(container, SWT.NONE); |
| label.setLayoutData(new GridData(SWT.RIGHT, SWT.CENTER, false, false, |
| 1, 1)); |
| label.setText(name); |
| |
| Combo combo = createOptionCombo(parameter, container, mValues.parameters, |
| this, this); |
| combo.setLayoutData(new GridData(SWT.FILL, SWT.CENTER, true, false, |
| 2, 1)); |
| |
| if (mFirst == null) { |
| mFirst = combo; |
| } |
| |
| if (help != null && !help.isEmpty()) { |
| ControlDecoration decoration = createFieldDecoration(id, combo, help); |
| } |
| break; |
| } |
| case SEPARATOR: |
| // Already handled above |
| assert false : type; |
| break; |
| default: |
| assert false : type; |
| } |
| } |
| } |
| |
| // Preview |
| mPreview = new ImageControl(parent, SWT.NONE, null); |
| mPreview.setDisposeImage(false); // Handled manually in this class |
| GridData gd_mImage = new GridData(SWT.CENTER, SWT.CENTER, false, false, 1, 1); |
| gd_mImage.widthHint = PREVIEW_WIDTH + 2 * PREVIEW_PADDING; |
| mPreview.setLayoutData(gd_mImage); |
| |
| Label separator = new Label(parent, SWT.SEPARATOR | SWT.HORIZONTAL); |
| GridData separatorData = new GridData(SWT.FILL, SWT.TOP, true, false, 3, 1); |
| separatorData.heightHint = 16; |
| separator.setLayoutData(separatorData); |
| |
| // Generic help |
| mHelpIcon = new Label(parent, SWT.NONE); |
| mHelpIcon.setLayoutData(new GridData(SWT.RIGHT, SWT.TOP, false, false, 1, 1)); |
| Image icon = IconFactory.getInstance().getIcon("quickfix"); |
| mHelpIcon.setImage(icon); |
| mHelpIcon.setVisible(false); |
| mTipLabel = new Label(parent, SWT.WRAP); |
| mTipLabel.setLayoutData(new GridData(SWT.FILL, SWT.FILL, true, true, 2, 1)); |
| |
| setPreview(thumb); |
| |
| parent.layout(true, true); |
| // TODO: This is a workaround for the fact that (at least on OSX) you end up |
| // with some visual artifacts from the control decorations in the upper left corner |
| // (outside the parent widget itself) from the initial control decoration placement |
| // prior to layout. Therefore, perform a redraw. A better solution would be to |
| // delay creation of the control decorations until layout has been performed. |
| // Let's do that soon. |
| parent.getParent().redraw(); |
| } |
| |
| @NonNull |
| static Combo createOptionCombo( |
| @NonNull Parameter parameter, |
| @NonNull Composite container, |
| @NonNull Map<String, Object> valueMap, |
| @NonNull SelectionListener selectionListener, |
| @NonNull FocusListener focusListener) { |
| Combo combo = new Combo(container, SWT.READ_ONLY); |
| |
| List<Element> options = parameter.getOptions(); |
| assert options.size() > 0; |
| int selected = 0; |
| List<String> ids = Lists.newArrayList(); |
| List<Integer> minSdks = Lists.newArrayList(); |
| List<Integer> minBuildApis = Lists.newArrayList(); |
| List<String> labels = Lists.newArrayList(); |
| for (int i = 0, n = options.size(); i < n; i++) { |
| Element option = options.get(i); |
| String optionId = option.getAttribute(ATTR_ID); |
| assert optionId != null && !optionId.isEmpty() : ATTR_ID; |
| String isDefault = option.getAttribute(ATTR_DEFAULT); |
| if (isDefault != null && !isDefault.isEmpty() && |
| Boolean.valueOf(isDefault)) { |
| selected = i; |
| } |
| NodeList childNodes = option.getChildNodes(); |
| assert childNodes.getLength() == 1 && |
| childNodes.item(0).getNodeType() == Node.TEXT_NODE; |
| String optionLabel = childNodes.item(0).getNodeValue().trim(); |
| |
| String minApiString = option.getAttribute(ATTR_MIN_API); |
| int minSdk = 1; |
| if (minApiString != null && !minApiString.isEmpty()) { |
| try { |
| minSdk = Integer.parseInt(minApiString); |
| } catch (NumberFormatException nufe) { |
| // Templates aren't allowed to contain codenames, should |
| // always be an integer |
| AdtPlugin.log(nufe, null); |
| minSdk = 1; |
| } |
| } |
| String minBuildApiString = option.getAttribute(ATTR_MIN_BUILD_API); |
| int minBuildApi = 1; |
| if (minBuildApiString != null && !minBuildApiString.isEmpty()) { |
| try { |
| minBuildApi = Integer.parseInt(minBuildApiString); |
| } catch (NumberFormatException nufe) { |
| // Templates aren't allowed to contain codenames, should |
| // always be an integer |
| AdtPlugin.log(nufe, null); |
| minBuildApi = 1; |
| } |
| } |
| minSdks.add(minSdk); |
| minBuildApis.add(minBuildApi); |
| ids.add(optionId); |
| labels.add(optionLabel); |
| } |
| combo.setData(parameter); |
| parameter.control = combo; |
| combo.setData(ATTR_ID, ids.toArray(new String[ids.size()])); |
| combo.setData(ATTR_MIN_API, minSdks.toArray(new Integer[minSdks.size()])); |
| combo.setData(ATTR_MIN_BUILD_API, minBuildApis.toArray( |
| new Integer[minBuildApis.size()])); |
| assert labels.size() > 0; |
| combo.setItems(labels.toArray(new String[labels.size()])); |
| combo.select(selected); |
| |
| combo.addSelectionListener(selectionListener); |
| combo.addFocusListener(focusListener); |
| |
| valueMap.put(parameter.id, ids.get(selected)); |
| |
| if (parameter.help != null && !parameter.help.isEmpty()) { |
| combo.setToolTipText(parameter.help); |
| } |
| |
| return combo; |
| } |
| |
| private void setPreview(String thumb) { |
| Image oldImage = mPreviewImage; |
| boolean dispose = mDisposePreviewImage; |
| mPreviewImage = null; |
| |
| if (thumb == null || thumb.isEmpty()) { |
| mPreviewImage = TemplateMetadata.getDefaultTemplateIcon(); |
| mDisposePreviewImage = false; |
| } else { |
| byte[] data = mValues.getTemplateHandler().readTemplateResource(thumb); |
| if (data != null) { |
| try { |
| mPreviewImage = new Image(getControl().getDisplay(), |
| new ByteArrayInputStream(data)); |
| mDisposePreviewImage = true; |
| } catch (Exception e) { |
| AdtPlugin.log(e, null); |
| } |
| } |
| if (mPreviewImage == null) { |
| return; |
| } |
| } |
| |
| mPreview.setImage(mPreviewImage); |
| mPreview.fitToWidth(PREVIEW_WIDTH); |
| |
| if (oldImage != null && dispose) { |
| oldImage.dispose(); |
| } |
| } |
| |
| @Override |
| public void dispose() { |
| super.dispose(); |
| |
| if (mPreviewImage != null && mDisposePreviewImage) { |
| mDisposePreviewImage = false; |
| mPreviewImage.dispose(); |
| mPreviewImage = null; |
| } |
| } |
| |
| private ControlDecoration createFieldDecoration(String id, Control control, |
| String description) { |
| ControlDecoration decoration = new ControlDecoration(control, SWT.LEFT); |
| decoration.setMarginWidth(2); |
| FieldDecoration errorFieldIndicator = FieldDecorationRegistry.getDefault(). |
| getFieldDecoration(FieldDecorationRegistry.DEC_INFORMATION); |
| decoration.setImage(errorFieldIndicator.getImage()); |
| decoration.setDescriptionText(description); |
| control.setToolTipText(description); |
| mDecorations.put(id, decoration); |
| |
| return decoration; |
| } |
| |
| @Override |
| public boolean isPageComplete() { |
| // Force user to reach this page before hitting Finish |
| return mShown && super.isPageComplete(); |
| } |
| |
| @Override |
| public void setVisible(boolean visible) { |
| if (visible) { |
| onEnter(); |
| } |
| |
| super.setVisible(visible); |
| |
| if (mFirst != null) { |
| mFirst.setFocus(); |
| } |
| |
| if (visible) { |
| mShown = true; |
| } |
| |
| validatePage(); |
| } |
| |
| /** Returns the parameter associated with the given control */ |
| @Nullable |
| static Parameter getParameter(Control control) { |
| return (Parameter) control.getData(); |
| } |
| |
| /** |
| * Returns the current string evaluator, if any |
| * |
| * @return the evaluator or null |
| */ |
| @Nullable |
| public StringEvaluator getEvaluator() { |
| return mEvaluator; |
| } |
| |
| // ---- Validation ---- |
| |
| private void validatePage() { |
| int minSdk = getMinSdk(); |
| int buildApi = getBuildApi(); |
| IStatus status = mValues.getTemplateHandler().validateTemplate(minSdk, buildApi); |
| |
| if (status == null || status.isOK()) { |
| if (mChooseProject && mValues.project == null) { |
| status = new Status(IStatus.ERROR, AdtPlugin.PLUGIN_ID, |
| "Please select an Android project."); |
| } |
| } |
| |
| for (Parameter parameter : mShowingTemplate.getParameters()) { |
| if (parameter.type == Parameter.Type.SEPARATOR) { |
| continue; |
| } |
| IInputValidator validator = parameter.getValidator(mValues.project); |
| if (validator != null) { |
| ControlDecoration decoration = mDecorations.get(parameter.id); |
| String value = parameter.value == null ? "" : parameter.value.toString(); |
| String error = validator.isValid(value); |
| if (error != null) { |
| IStatus s = new Status(IStatus.ERROR, AdtPlugin.PLUGIN_ID, error); |
| if (decoration != null) { |
| updateDecorator(decoration, s, parameter.help); |
| } |
| if (status == null || status.isOK()) { |
| status = s; |
| } |
| } else if (decoration != null) { |
| updateDecorator(decoration, null, parameter.help); |
| } |
| } |
| |
| if (status == null || status.isOK()) { |
| if (parameter.control instanceof Combo) { |
| status = validateCombo(status, parameter, minSdk, buildApi); |
| } |
| } |
| } |
| |
| setPageComplete(status == null || status.getSeverity() != IStatus.ERROR); |
| if (status != null) { |
| setMessage(status.getMessage(), |
| status.getSeverity() == IStatus.ERROR |
| ? IMessageProvider.ERROR : IMessageProvider.WARNING); |
| } else { |
| setErrorMessage(null); |
| setMessage(null); |
| } |
| } |
| |
| /** Validates the given combo */ |
| static IStatus validateCombo(IStatus status, Parameter parameter, int minSdk, int buildApi) { |
| Combo combo = (Combo) parameter.control; |
| int index = combo.getSelectionIndex(); |
| return validateCombo(status, parameter, index, minSdk, buildApi); |
| } |
| |
| /** Validates the given combo assuming the value at the given index is chosen */ |
| static IStatus validateCombo(IStatus status, Parameter parameter, int index, |
| int minSdk, int buildApi) { |
| Combo combo = (Combo) parameter.control; |
| Integer[] optionIds = (Integer[]) combo.getData(ATTR_MIN_API); |
| // Check minSdk |
| if (index != -1 && index < optionIds.length) { |
| Integer requiredMinSdk = optionIds[index]; |
| if (requiredMinSdk > minSdk) { |
| status = new Status(IStatus.ERROR, AdtPlugin.PLUGIN_ID, |
| String.format( |
| "%1$s \"%2$s\" requires a minimum SDK version of at " + |
| "least %3$d, and the current min version is %4$d", |
| parameter.name, combo.getItems()[index], requiredMinSdk, minSdk)); |
| } |
| } |
| |
| // Check minimum build target |
| optionIds = (Integer[]) combo.getData(ATTR_MIN_BUILD_API); |
| if (index != -1 && index < optionIds.length) { |
| Integer requiredBuildApi = optionIds[index]; |
| if (requiredBuildApi > buildApi) { |
| status = new Status(IStatus.ERROR, AdtPlugin.PLUGIN_ID, |
| String.format( |
| "%1$s \"%2$s\" requires a build target API version of at " + |
| "least %3$d, and the current version is %4$d", |
| parameter.name, combo.getItems()[index], requiredBuildApi, buildApi)); |
| } |
| } |
| return status; |
| } |
| |
| private int getMinSdk() { |
| return mChooseProject ? mValues.getMinSdk() : mCustomMinSdk; |
| } |
| |
| private int getBuildApi() { |
| return mChooseProject ? mValues.getBuildApi() : mCustomBuildApi; |
| } |
| |
| private void updateDecorator(ControlDecoration decorator, IStatus status, String help) { |
| if (help != null && !help.isEmpty()) { |
| decorator.setDescriptionText(status != null ? status.getMessage() : help); |
| |
| int severity = status != null ? status.getSeverity() : IStatus.OK; |
| String id; |
| if (severity == IStatus.ERROR) { |
| id = FieldDecorationRegistry.DEC_ERROR; |
| } else if (severity == IStatus.WARNING) { |
| id = FieldDecorationRegistry.DEC_WARNING; |
| } else { |
| id = FieldDecorationRegistry.DEC_INFORMATION; |
| } |
| FieldDecoration errorFieldIndicator = FieldDecorationRegistry.getDefault(). |
| getFieldDecoration(id); |
| decorator.setImage(errorFieldIndicator.getImage()); |
| } else { |
| if (status == null || status.isOK()) { |
| decorator.hide(); |
| } else { |
| decorator.show(); |
| } |
| } |
| } |
| |
| // ---- Implements ModifyListener ---- |
| |
| @Override |
| public void modifyText(ModifyEvent e) { |
| if (mIgnore) { |
| return; |
| } |
| |
| Object source = e.getSource(); |
| if (source instanceof Text) { |
| Text text = (Text) source; |
| editParameter(text, text.getText().trim()); |
| } |
| |
| validatePage(); |
| } |
| |
| // ---- Implements SelectionListener ---- |
| |
| @Override |
| public void widgetSelected(SelectionEvent e) { |
| if (mIgnore) { |
| return; |
| } |
| |
| Object source = e.getSource(); |
| if (source == mProjectButton) { |
| mValues.project = mProjectButton.getSelectedProject(); |
| } else if (source instanceof Combo) { |
| Combo combo = (Combo) source; |
| String[] optionIds = (String[]) combo.getData(ATTR_ID); |
| int index = combo.getSelectionIndex(); |
| if (index != -1 && index < optionIds.length) { |
| String optionId = optionIds[index]; |
| editParameter(combo, optionId); |
| TemplateMetadata template = mValues.getTemplateHandler().getTemplate(); |
| if (template != null) { |
| setPreview(template.getThumbnailPath()); |
| } |
| } |
| } else if (source instanceof Button) { |
| Button button = (Button) source; |
| Parameter parameter = (Parameter) button.getData(); |
| if (parameter.type == Type.BOOLEAN) { |
| // Checkbox parameter |
| editParameter(button, button.getSelection()); |
| |
| TemplateMetadata template = mValues.getTemplateHandler().getTemplate(); |
| if (template != null) { |
| setPreview(template.getThumbnailPath()); |
| } |
| } else { |
| // Choose button for some other parameter, usually a text |
| String activity = chooseActivity(); |
| if (activity != null) { |
| setValue(parameter, activity); |
| } |
| } |
| } |
| |
| validatePage(); |
| } |
| |
| private String chooseActivity() { |
| try { |
| // Compute a search scope: We need to merge all the subclasses |
| // android.app.Fragment and android.support.v4.app.Fragment |
| IJavaSearchScope scope = SearchEngine.createWorkspaceScope(); |
| IProject project = mValues.project; |
| IJavaProject javaProject = BaseProjectHelper.getJavaProject(project); |
| IType activityType = null; |
| |
| if (javaProject != null) { |
| activityType = javaProject.findType(CLASS_ACTIVITY); |
| } |
| if (activityType == null) { |
| IJavaProject[] projects = BaseProjectHelper.getAndroidProjects(null); |
| for (IJavaProject p : projects) { |
| activityType = p.findType(CLASS_ACTIVITY); |
| if (activityType != null) { |
| break; |
| } |
| } |
| } |
| if (activityType != null) { |
| NullProgressMonitor monitor = new NullProgressMonitor(); |
| ITypeHierarchy hierarchy = activityType.newTypeHierarchy(monitor); |
| IType[] classes = hierarchy.getAllSubtypes(activityType); |
| scope = SearchEngine.createJavaSearchScope(classes, IJavaSearchScope.SOURCES); |
| } |
| |
| Shell parent = AdtPlugin.getShell(); |
| final SelectionDialog dialog = JavaUI.createTypeDialog( |
| parent, |
| new ProgressMonitorDialog(parent), |
| scope, |
| IJavaElementSearchConstants.CONSIDER_CLASSES, false, |
| // Use ? as a default filter to fill dialog with matches |
| "?", //$NON-NLS-1$ |
| new TypeSelectionExtension() { |
| @Override |
| public ITypeInfoFilterExtension getFilterExtension() { |
| return new ITypeInfoFilterExtension() { |
| @Override |
| public boolean select(ITypeInfoRequestor typeInfoRequestor) { |
| int modifiers = typeInfoRequestor.getModifiers(); |
| if (!Flags.isPublic(modifiers) |
| || Flags.isInterface(modifiers) |
| || Flags.isEnum(modifiers)) { |
| return false; |
| } |
| return true; |
| } |
| }; |
| } |
| }); |
| |
| dialog.setTitle("Choose Activity Class"); |
| dialog.setMessage("Select an Activity class (? = any character, * = any string):"); |
| if (dialog.open() == IDialogConstants.CANCEL_ID) { |
| return null; |
| } |
| |
| Object[] types = dialog.getResult(); |
| if (types != null && types.length > 0) { |
| return ((IType) types[0]).getFullyQualifiedName(); |
| } |
| } catch (JavaModelException e) { |
| AdtPlugin.log(e, null); |
| } catch (CoreException e) { |
| AdtPlugin.log(e, null); |
| } |
| return null; |
| } |
| |
| private void editParameter(Control control, Object value) { |
| Parameter parameter = getParameter(control); |
| if (parameter != null) { |
| String id = parameter.id; |
| parameter.value = value; |
| parameter.edited = value != null && !value.toString().isEmpty(); |
| mValues.parameters.put(id, value); |
| |
| // Update dependent variables, if any |
| List<Parameter> parameters = mShowingTemplate.getParameters(); |
| for (Parameter p : parameters) { |
| if (p == parameter || p.suggest == null || p.edited || |
| p.type == Parameter.Type.SEPARATOR) { |
| continue; |
| } |
| if (!p.suggest.contains(id)) { |
| continue; |
| } |
| |
| try { |
| if (mEvaluator == null) { |
| mEvaluator = new StringEvaluator(); |
| } |
| String updated = mEvaluator.evaluate(p.suggest, parameters); |
| if (updated != null && !updated.equals(p.value)) { |
| setValue(p, updated); |
| } |
| } catch (Throwable t) { |
| // Pass: Ignore updating if something wrong happens |
| t.printStackTrace(); // during development only |
| } |
| } |
| } |
| } |
| |
| private void setValue(Parameter p, String value) { |
| p.value = value; |
| mValues.parameters.put(p.id, value); |
| |
| // Update form widgets |
| boolean prevIgnore = mIgnore; |
| try { |
| mIgnore = true; |
| if (p.control instanceof Text) { |
| ((Text) p.control).setText(value); |
| } else if (p.control instanceof Button) { |
| // TODO: Handle |
| } else if (p.control instanceof Combo) { |
| // TODO: Handle |
| } else if (p.control != null) { |
| assert false : p.control; |
| } |
| } finally { |
| mIgnore = prevIgnore; |
| } |
| } |
| |
| @Override |
| public void widgetDefaultSelected(SelectionEvent e) { |
| } |
| |
| // ---- Implements FocusListener ---- |
| |
| @Override |
| public void focusGained(FocusEvent e) { |
| Object source = e.getSource(); |
| String tip = ""; |
| |
| if (source instanceof Control) { |
| Control control = (Control) source; |
| Parameter parameter = getParameter(control); |
| if (parameter != null) { |
| ControlDecoration decoration = mDecorations.get(parameter.id); |
| if (decoration != null) { |
| tip = decoration.getDescriptionText(); |
| } |
| } |
| } |
| |
| mTipLabel.setText(tip); |
| mHelpIcon.setVisible(tip.length() > 0); |
| } |
| |
| @Override |
| public void focusLost(FocusEvent e) { |
| mTipLabel.setText(""); |
| mHelpIcon.setVisible(false); |
| } |
| } |
