| /* |
| * Copyright (C) 2012 The Android Open Source Project |
| * |
| * Licensed under the Apache License, Version 2.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.apache.org/licenses/LICENSE-2.0 |
| * |
| * 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.motorola.studio.android.wizards.buildingblocks; |
| |
| import java.util.Arrays; |
| import java.util.HashSet; |
| import java.util.Set; |
| import java.util.regex.Matcher; |
| import java.util.regex.Pattern; |
| |
| import org.eclipse.core.resources.IResource; |
| import org.eclipse.core.resources.IWorkspaceRoot; |
| import org.eclipse.core.resources.ResourcesPlugin; |
| import org.eclipse.core.runtime.CoreException; |
| import org.eclipse.core.runtime.IStatus; |
| import org.eclipse.core.runtime.MultiStatus; |
| import org.eclipse.core.runtime.Status; |
| import org.eclipse.jdt.core.IJavaElement; |
| import org.eclipse.jdt.core.IJavaProject; |
| import org.eclipse.jdt.core.IPackageFragment; |
| import org.eclipse.jdt.core.IPackageFragmentRoot; |
| import org.eclipse.jdt.core.JavaCore; |
| import org.eclipse.jdt.core.JavaModelException; |
| import org.eclipse.jdt.ui.JavaElementComparator; |
| import org.eclipse.jdt.ui.JavaElementLabelProvider; |
| import org.eclipse.jdt.ui.StandardJavaElementContentProvider; |
| import org.eclipse.jdt.ui.wizards.NewTypeWizardPage; |
| import org.eclipse.jface.dialogs.Dialog; |
| import org.eclipse.jface.viewers.ILabelProvider; |
| import org.eclipse.jface.viewers.ViewerFilter; |
| import org.eclipse.jface.window.Window; |
| import org.eclipse.osgi.util.NLS; |
| import org.eclipse.swt.SWT; |
| import org.eclipse.swt.custom.ScrolledComposite; |
| import org.eclipse.swt.events.ControlAdapter; |
| import org.eclipse.swt.events.ControlEvent; |
| import org.eclipse.swt.events.ShellEvent; |
| import org.eclipse.swt.events.ShellListener; |
| import org.eclipse.swt.layout.FillLayout; |
| import org.eclipse.swt.layout.GridData; |
| import org.eclipse.swt.layout.GridLayout; |
| import org.eclipse.swt.widgets.Button; |
| import org.eclipse.swt.widgets.Composite; |
| import org.eclipse.swt.widgets.Event; |
| import org.eclipse.swt.widgets.Label; |
| import org.eclipse.swt.widgets.List; |
| import org.eclipse.swt.widgets.Listener; |
| import org.eclipse.swt.widgets.Shell; |
| import org.eclipse.swt.widgets.Text; |
| import org.eclipse.ui.PlatformUI; |
| import org.eclipse.ui.dialogs.ElementTreeSelectionDialog; |
| import org.eclipse.ui.dialogs.ISelectionStatusValidator; |
| |
| import com.motorola.studio.android.codeutils.CodeUtilsActivator; |
| import com.motorola.studio.android.codeutils.i18n.CodeUtilsNLS; |
| import com.motorola.studio.android.common.IAndroidConstants; |
| import com.motorola.studio.android.common.exception.AndroidException; |
| import com.motorola.studio.android.common.log.StudioLogger; |
| import com.motorola.studio.android.common.utilities.AndroidUtils; |
| import com.motorola.studio.android.common.utilities.EclipseUtils; |
| import com.motorola.studio.android.manifest.AndroidProjectManifestFile; |
| import com.motorola.studio.android.model.BuildingBlockModel; |
| import com.motorola.studio.android.model.manifest.AndroidManifestFile; |
| import com.motorola.studio.android.wizards.elements.AddRemoveButtons; |
| |
| /** |
| * Abstract class used to create the building block wizard main pages. |
| */ |
| public abstract class NewBuildingBlocksWizardPage extends NewTypeWizardPage |
| { |
| private static final String JAVA_EXTENSION = ".java"; //$NON-NLS-1$ |
| |
| private static final int MAX_PATH_SIZE = 255; |
| |
| protected static String LABEL = TYPENAME + ".LABEL"; //$NON-NLS-1$ |
| |
| protected IWorkspaceRoot fWorkspaceRoot = ResourcesPlugin.getWorkspace().getRoot(); |
| |
| private BuildingBlockModel buildBlock; |
| |
| private Text labelText; |
| |
| private Button defaultLabelButton; |
| |
| private AddRemoveButtons addRemovePermissionsButtons; |
| |
| private List activityPermissions; |
| |
| private final Set<String> intentFilterPermissions = new HashSet<String>(); |
| |
| private MethodCreationControl methodCreationControl; |
| |
| /** |
| * Listener to check if the wizard can be opened. |
| */ |
| private class WizardShellListener implements ShellListener |
| { |
| private boolean wasChecked = false; |
| |
| /* |
| * (non-Javadoc) |
| * |
| * @see |
| * org.eclipse.swt.events.ShellListener#shellActivated(org.eclipse.swt |
| * .events.ShellEvent) |
| */ |
| @Override |
| public void shellActivated(ShellEvent e) |
| { |
| if (!wasChecked) |
| { |
| wasChecked = true; |
| |
| if (!canOpen()) |
| { |
| ((Shell) e.widget).close(); |
| } |
| } |
| |
| } |
| |
| /* |
| * (non-Javadoc) |
| * |
| * @see |
| * org.eclipse.swt.events.ShellListener#shellClosed(org.eclipse.swt. |
| * events.ShellEvent) |
| */ |
| @Override |
| public void shellClosed(ShellEvent e) |
| { |
| // Do nothing |
| } |
| |
| /* |
| * (non-Javadoc) |
| * |
| * @see |
| * org.eclipse.swt.events.ShellListener#shellDeactivated(org.eclipse |
| * .swt.events.ShellEvent) |
| */ |
| @Override |
| public void shellDeactivated(ShellEvent e) |
| { |
| // Do nothing |
| } |
| |
| /* |
| * (non-Javadoc) |
| * |
| * @see |
| * org.eclipse.swt.events.ShellListener#shellDeiconified(org.eclipse |
| * .swt.events.ShellEvent) |
| */ |
| @Override |
| public void shellDeiconified(ShellEvent e) |
| { |
| // Do nothing |
| } |
| |
| /* |
| * (non-Javadoc) |
| * |
| * @see |
| * org.eclipse.swt.events.ShellListener#shellIconified(org.eclipse.swt |
| * .events.ShellEvent) |
| */ |
| @Override |
| public void shellIconified(ShellEvent e) |
| { |
| // Do nothing |
| } |
| |
| } |
| |
| /* Each building block is represent by a class (e.g., an Activity or Service). |
| * Each of these classes contain some methods that must be overridden by subclasses |
| * in order to be called by android framework (e.g., onCreate(...) methods). |
| * This class is responsible to create check boxes that let users choose which of these methods |
| * should be automatically created by the wizard. |
| * */ |
| private class MethodCreationControl |
| { |
| private Label stubMessage; |
| |
| private Button[] stubButtonArray; |
| |
| MethodCreationControl(Composite parent, Method[] methods) |
| { |
| if (methods != null) |
| { |
| if (methods.length > 0) |
| { |
| stubMessage = new Label(parent, SWT.NONE); |
| stubMessage.setLayoutData(new GridData(GridData.FILL, GridData.FILL, false, |
| false, 4, 1)); |
| stubMessage |
| .setText(CodeUtilsNLS.UI_NewBuildingBlocksWizardPage_QuestionWhichMethodCreate); |
| } |
| |
| createStubsComponent(parent, methods); |
| } |
| } |
| |
| /* |
| * Creates a single method declaration to the wizard page |
| * |
| * @param parent |
| * The wizard page composite |
| * @param method |
| * The method to add |
| */ |
| private void createStubsComponent(Composite parent, Method[] methods) |
| { |
| stubButtonArray = new Button[methods.length]; |
| int i = 0; |
| for (final Method method : methods) |
| { |
| new Label(parent, SWT.NONE); |
| final Button stubsButton = new Button(parent, SWT.CHECK); |
| stubsButton.setLayoutData(new GridData(GridData.FILL, GridData.FILL, false, false, |
| 3, 1)); |
| stubsButton.setText(method.getMessage()); |
| stubsButton.addListener(SWT.Selection, new Listener() |
| { |
| @Override |
| public void handleEvent(Event event) |
| { |
| method.handle(stubsButton.getSelection()); |
| } |
| }); |
| stubButtonArray[i++] = stubsButton; |
| } |
| } |
| |
| public void setMethodCreationControlEnabled(boolean enabled) |
| { |
| stubMessage.setEnabled(enabled); |
| for (Button stubButton : stubButtonArray) |
| { |
| stubButton.setEnabled(enabled); |
| } |
| } |
| } |
| |
| /** |
| * Default constructor. |
| * |
| * @param buildBlock |
| * The building block model that the wizard will create. |
| * @param pageName |
| * The page name. |
| */ |
| protected NewBuildingBlocksWizardPage(BuildingBlockModel buildBlock, String pageName) |
| { |
| super(true, pageName); |
| this.buildBlock = buildBlock; |
| setTitle(getWizardTitle()); |
| setDescription(getDefaultMessage()); |
| setPageComplete(false); |
| } |
| |
| /** |
| * Gets the help ID to be used for attaching context sensitive help. |
| * |
| * Classes that extends this class and want to set their own help should |
| * override this method. |
| */ |
| protected abstract String getHelpId(); |
| |
| /** |
| * Returns the wizard title. |
| * |
| * @return the wizard title. |
| */ |
| public abstract String getWizardTitle(); |
| |
| /** |
| * Returns the wizard default status message. |
| * |
| * @return the wizard default status message. |
| */ |
| public abstract String getDefaultMessage(); |
| |
| /** |
| * Returns all methods that the building block can override. |
| * |
| * @return all methods that the building block can override. |
| */ |
| protected abstract Method[] getMethods(); |
| |
| /** |
| * @param enabled If true, all available methods in the building block will be checked |
| * for automatic creation. |
| * */ |
| public void setMethodCreationControlEnabled(boolean enabled) |
| { |
| methodCreationControl.setMethodCreationControlEnabled(enabled); |
| } |
| |
| /* |
| * (non-Javadoc) |
| * |
| * @see |
| * org.eclipse.jface.dialogs.IDialogPage#createControl(org.eclipse.swt.widgets |
| * .Composite) |
| */ |
| @Override |
| public void createControl(Composite parent) |
| { |
| initializeDialogUnits(parent); |
| |
| // main control |
| Composite mainComposite = new Composite(parent, SWT.FILL); |
| mainComposite.setLayout(new FillLayout(SWT.FILL)); |
| final ScrolledComposite scroll = |
| new ScrolledComposite(mainComposite, SWT.H_SCROLL | SWT.V_SCROLL); |
| |
| final Composite composite = new Composite(scroll, SWT.NONE); |
| composite.setFont(parent.getFont()); |
| |
| int nColumns = 4; |
| |
| createSampleControls(composite, nColumns); |
| |
| GridLayout layout = new GridLayout(nColumns, false); |
| composite.setLayout(layout); |
| composite.setLayoutData(new GridData(GridData.FILL, GridData.FILL, true, true)); |
| |
| if (hasHeader()) |
| { |
| setPackageFragmentRoot(getBuildBlock().getPackageFragmentRoot(), true); |
| createContainerControls(composite, nColumns); |
| setPackageFragment(getBuildBlock().getPackageFragment(), true); |
| createPackageControls(composite, nColumns); |
| |
| createSeparator(composite, nColumns); |
| |
| createTypeNameControls(composite, nColumns); |
| |
| createLabelControls(composite); |
| |
| setSuperClass(getBuildBlock().getSuperClass(), getBuildBlock().useExtendedClass()); |
| createSuperClassControls(composite, nColumns); |
| |
| createPermissionControls(composite); |
| |
| createIntermediateControls(composite); |
| |
| createMethodCreationControl(composite, getMethods()); |
| } |
| createExtendedControls(composite); |
| |
| // set up scroll |
| scroll.setContent(composite); |
| |
| scroll.setExpandHorizontal(true); |
| scroll.setExpandVertical(true); |
| |
| scroll.addControlListener(new ControlAdapter() |
| { |
| @Override |
| public void controlResized(ControlEvent e) |
| { |
| scroll.setMinSize(composite.computeSize(SWT.DEFAULT, SWT.DEFAULT)); |
| } |
| }); |
| |
| setControl(mainComposite); |
| Dialog.applyDialogFont(mainComposite); |
| |
| mainComposite.getShell().addShellListener(new WizardShellListener()); |
| PlatformUI.getWorkbench().getHelpSystem().setHelp(parent, getHelpId()); |
| PlatformUI.getWorkbench().getHelpSystem().setHelp(mainComposite, getHelpId()); |
| } |
| |
| /** |
| * Override this class to create the label controls. |
| * |
| * @param parent |
| * The wizard page composite |
| */ |
| protected void createLabelControls(Composite parent) |
| { |
| Label label = new Label(parent, SWT.NONE); |
| label.setText(CodeUtilsNLS.UI_NewBuildingBlocksWizardPage_TextLabel); |
| |
| labelText = new Text(parent, SWT.BORDER); |
| GridData gridData = new GridData(GridData.FILL_HORIZONTAL); |
| gridData.horizontalSpan = 2; |
| labelText.setLayoutData(gridData); |
| labelText.setEnabled(false); |
| |
| defaultLabelButton = new Button(parent, SWT.CHECK); |
| defaultLabelButton.setText(CodeUtilsNLS.UI_NewBuildingBlocksWizardPage_ButtonNameDefault); |
| defaultLabelButton.setSelection(true); |
| |
| Listener listener = new Listener() |
| { |
| @Override |
| public void handleEvent(Event event) |
| { |
| if (!defaultLabelButton.getSelection() || !event.widget.equals(labelText)) |
| { |
| handleFieldChanged(LABEL); |
| } |
| if (event.widget.equals(defaultLabelButton) && !defaultLabelButton.getSelection() |
| && labelText.isEnabled()) |
| { |
| labelText.forceFocus(); |
| labelText.selectAll(); |
| } |
| } |
| }; |
| |
| labelText.addListener(SWT.Modify, listener); |
| defaultLabelButton.addListener(SWT.Selection, listener); |
| } |
| |
| /** |
| * Override this class to add samples control. |
| * |
| * @param composite |
| * The wizard page composite |
| */ |
| protected void createSampleControls(Composite composite, int nColumns) |
| { |
| //default implementation does nothing |
| } |
| |
| /** |
| * Override this class to add components after superclass control. |
| * |
| * @param composite |
| * The wizard page composite |
| */ |
| protected void createIntermediateControls(Composite composite) |
| { |
| //default implementation does nothing |
| } |
| |
| /** |
| * Return all Filter Permissions as an Array. |
| * |
| * @return |
| */ |
| public String[] getIntentFilterPermissionsAsArray() |
| { |
| return intentFilterPermissions.toArray(new String[intentFilterPermissions.size()]); |
| } |
| |
| /** |
| * Creates the "Permissions" section on the wizard. |
| * |
| * @param composite |
| * the wizard composite |
| */ |
| protected void createPermissionControls(Composite composite) |
| { |
| GridData gridData; |
| Label activityPermissionsLabel = new Label(composite, SWT.NONE); |
| activityPermissionsLabel.setText(CodeUtilsNLS.NewBuildingBlocksWizardPage_PermissionLabel); |
| gridData = new GridData(SWT.LEFT, SWT.CENTER, false, false); |
| gridData.verticalAlignment = GridData.BEGINNING; |
| activityPermissionsLabel.setLayoutData(gridData); |
| |
| activityPermissions = new List(composite, SWT.BORDER | SWT.V_SCROLL | SWT.H_SCROLL); |
| activityPermissions.setItems(getBuildBlock().getIntentFilterPermissionsAsArray()); |
| gridData = new GridData(SWT.FILL, SWT.CENTER, true, false, 2, 1); |
| gridData.heightHint = convertHeightInCharsToPixels(3); |
| activityPermissions.setLayoutData(gridData); |
| |
| addRemovePermissionsButtons = new AddRemoveButtons(composite); |
| setButtonLayoutData(addRemovePermissionsButtons.getAddButton()); |
| setButtonLayoutData(addRemovePermissionsButtons.getRemoveButton()); |
| addRemovePermissionsButtons.getAddButton().addListener(SWT.Selection, new Listener() |
| { |
| @Override |
| public void handleEvent(Event arg0) |
| { |
| Set<String> permissionSet = |
| new HashSet<String>(Arrays.asList(AndroidUtils |
| .getIntentFilterPermissions(getBuildBlock().getProject()))); |
| |
| permissionSet.removeAll(getBuildBlock().getIntentFilterPermissions()); |
| |
| FilteredActionsSelectionDialog dialog = |
| new FilteredActionsSelectionDialog(getShell(), permissionSet); |
| dialog.setInitialPattern("**"); //$NON-NLS-1$ |
| dialog.setTitle("Select an action permission"); //$NON-NLS-1$ |
| dialog.setMessage(CodeUtilsNLS.UI_NewLauncherWizardPage_CategorySelectionDialogMessage); |
| |
| if (Dialog.OK == dialog.open()) |
| { |
| for (Object result : dialog.getResult()) |
| { |
| getBuildBlock().addIntentFilterPermissions((String) result); |
| } |
| activityPermissions.setItems(getBuildBlock() |
| .getIntentFilterPermissionsAsArray()); |
| addRemovePermissionsButtons.getRemoveButton().setEnabled( |
| activityPermissions.getSelectionCount() > 0); |
| updateStatus(getBuildBlock().getStatus()); |
| } |
| } |
| }); |
| addRemovePermissionsButtons.getRemoveButton().addListener(SWT.Selection, new Listener() |
| { |
| @Override |
| public void handleEvent(Event arg0) |
| { |
| for (int selection : activityPermissions.getSelectionIndices()) |
| { |
| getBuildBlock().removeIntentFilterPermissions( |
| activityPermissions.getItem(selection)); |
| } |
| activityPermissions.setItems(getBuildBlock().getIntentFilterPermissionsAsArray()); |
| addRemovePermissionsButtons.getRemoveButton().setEnabled( |
| activityPermissions.getSelectionCount() > 0); |
| updateStatus(getBuildBlock().getStatus()); |
| } |
| }); |
| addRemovePermissionsButtons.getRemoveButton().setEnabled( |
| activityPermissions.getSelectionCount() > 0); |
| activityPermissions.addListener(SWT.Selection, new Listener() |
| { |
| @Override |
| public void handleEvent(Event arg0) |
| { |
| addRemovePermissionsButtons.getRemoveButton().setEnabled( |
| activityPermissions.getSelectionCount() > 0); |
| } |
| }); |
| } |
| |
| /** |
| * Override this class to add components at the end of the Page. |
| * |
| * @param parent |
| * The wizard page composite |
| */ |
| protected void createExtendedControls(Composite parent) |
| { |
| //default implementation does nothing |
| } |
| |
| /* |
| * (non-Javadoc) |
| * |
| * @see org.eclipse.jdt.ui.wizards.NewElementWizardPage#setVisible(boolean) |
| */ |
| @Override |
| public void setVisible(boolean visible) |
| { |
| super.setVisible(visible); |
| if (visible) |
| { |
| setFocus(); |
| } |
| } |
| |
| /** |
| * Returns true if page has header false otherwise. |
| * |
| * @return true if page has header false otherwise. |
| */ |
| public boolean hasHeader() |
| { |
| return true; |
| } |
| |
| /** |
| * Adds the methods that a building block can override to the wizard page. |
| * |
| * @param parent |
| * The wizard page composite. |
| * @param methods |
| * The methods to add to the wizard. |
| */ |
| protected void createMethodCreationControl(Composite parent, Method[] methods) |
| { |
| methodCreationControl = new MethodCreationControl(parent, methods); |
| } |
| |
| /* |
| * (non-Javadoc) |
| * |
| * @see org.eclipse.jdt.ui.wizards.NewContainerWizardPage#chooseContainer() |
| */ |
| @Override |
| protected IPackageFragmentRoot chooseContainer() |
| { |
| IJavaElement initElement = getPackageFragmentRoot(); |
| |
| ISelectionStatusValidator validator = new ElementTreeValidator(); |
| ViewerFilter filter = new ElementTreeViewFilter(); |
| StandardJavaElementContentProvider provider = new ElementTreeContentProvider(); |
| |
| ILabelProvider labelProvider = |
| new JavaElementLabelProvider(JavaElementLabelProvider.SHOW_DEFAULT); |
| ElementTreeSelectionDialog dialog = |
| new ElementTreeSelectionDialog(getShell(), labelProvider, provider); |
| dialog.setComparator(new JavaElementComparator()); |
| dialog.setValidator(validator); |
| dialog.setTitle(CodeUtilsNLS.UI_NewBuildingBlocksWizardPage_WizardTitle); |
| dialog.setMessage(CodeUtilsNLS.UI_NewBuildingBlocksWizardPage_MessageChooseFolder); |
| dialog.setInput(JavaCore.create(fWorkspaceRoot)); |
| dialog.setInitialSelection(initElement); |
| dialog.addFilter(filter); |
| dialog.setHelpAvailable(false); |
| |
| IPackageFragmentRoot rootSelection = null; |
| if (dialog.open() == Window.OK) |
| { |
| Object element = dialog.getFirstResult(); |
| if (element instanceof IJavaProject) |
| { |
| IJavaProject jproject = (IJavaProject) element; |
| rootSelection = jproject.getPackageFragmentRoot(jproject.getProject()); |
| } |
| else if (element instanceof IPackageFragmentRoot) |
| { |
| rootSelection = (IPackageFragmentRoot) element; |
| } |
| } |
| return rootSelection; |
| } |
| |
| /* |
| * (non-Javadoc) |
| * |
| * @see |
| * org.eclipse.jdt.ui.wizards.NewTypeWizardPage#handleFieldChanged(java. |
| * lang.String) |
| */ |
| @Override |
| protected void handleFieldChanged(String fieldName) |
| { |
| if (NewTypeWizardPage.TYPENAME.equals(fieldName)) |
| { |
| getBuildBlock().setName(getTypeName()); |
| getBuildBlock().setNameStatus(typeNameChanged()); |
| getBuildBlock().setPackageStatus(packageChanged()); |
| } |
| else if (NewTypeWizardPage.CONTAINER.equals(fieldName)) |
| { |
| // source folder |
| getBuildBlock().setPackageFragmentRoot(getPackageFragmentRoot()); |
| getBuildBlock().setPackageFragmentRootStatus(containerChanged()); |
| getBuildBlock().setPackageStatus(packageChanged()); |
| getBuildBlock().setNameStatus(typeNameChanged()); |
| |
| updatePackage(getPackageFragmentRoot()); |
| } |
| else if (NewTypeWizardPage.PACKAGE.equals(fieldName)) |
| { |
| if (getPackageFragmentRoot() != null) |
| { |
| getBuildBlock().setPackageFragment( |
| getPackageFragmentRoot().getPackageFragment(getPackageText())); |
| } |
| getBuildBlock().setPackageStatus(packageChanged()); |
| getBuildBlock().setNameStatus(typeNameChanged()); |
| } |
| else if (LABEL.equals(fieldName)) |
| { |
| getBuildBlock().setLabelStatus(labelChanged()); |
| } |
| updateStatus(getBuildBlock().getStatus()); |
| } |
| |
| private void updatePackage(IPackageFragmentRoot packageFragmentRoot) |
| { |
| if (packageFragmentRoot != null) |
| { |
| IJavaProject project = null; |
| IPackageFragment pack = null; |
| |
| project = packageFragmentRoot.getJavaProject(); |
| try |
| { |
| pack = EclipseUtils.getDefaultPackageFragment(project); |
| getBuildBlock().setPackageFragment(pack); |
| } |
| catch (JavaModelException e) |
| { |
| StudioLogger.error(NewBuildingBlocksWizardPage.class, |
| "Error getting default package fragment.", e); //$NON-NLS-1$ |
| // do nothing |
| } |
| setPackageFragment(pack, true); |
| handleFieldChanged(NewTypeWizardPage.PACKAGE); |
| } |
| } |
| |
| /** |
| * @return A status indicating if the building block label property has been change. |
| */ |
| protected IStatus labelChanged() |
| { |
| IStatus status = new Status(IStatus.OK, CodeUtilsActivator.PLUGIN_ID, null); |
| if ((defaultLabelButton != null) && (labelText != null)) |
| { |
| if (defaultLabelButton.getSelection()) |
| { |
| labelText.setText(""); //$NON-NLS-1$ |
| |
| } |
| labelText.setEnabled(!defaultLabelButton.getSelection()); |
| getBuildBlock().setLabel(getLabel()); |
| } |
| return status; |
| } |
| |
| /* |
| * (non-Javadoc) |
| * |
| * @see org.eclipse.jdt.ui.wizards.NewTypeWizardPage#typeNameChanged() |
| */ |
| @Override |
| protected IStatus typeNameChanged() |
| { |
| IStatus superStatus = super.typeNameChanged(); |
| IStatus status = |
| new Status(superStatus.getSeverity(), CodeUtilsActivator.PLUGIN_ID, |
| superStatus.getMessage()); |
| |
| Pattern pattern = Pattern.compile("([A-Za-z0-9_]+)"); //$NON-NLS-1$ |
| |
| if (superStatus.getSeverity() != IStatus.ERROR) |
| { |
| Matcher matcher = pattern.matcher(getTypeName()); |
| |
| if (!matcher.matches() || !matcher.group().equals(getTypeName())) |
| { |
| String errMsg = |
| NLS.bind(CodeUtilsNLS.ERR_NewBuildingBlocksWizardPage_InvalidTypeName, |
| getTypeName()); |
| |
| status = new Status(IStatus.ERROR, CodeUtilsActivator.PLUGIN_ID, errMsg); |
| } |
| else if (packageAndClassExist()) |
| { |
| status = |
| new Status( |
| IStatus.ERROR, |
| CodeUtilsActivator.PLUGIN_ID, |
| CodeUtilsNLS.ERR_NewBuildingBlocksWizardPage_PackageAndClassAlreadyExist); |
| } |
| else if (isTooLongOnFileSystem()) |
| { |
| status = |
| new Status(IStatus.ERROR, CodeUtilsActivator.PLUGIN_ID, |
| CodeUtilsNLS.ERR_NewBuildingBlocksWizardPage_FileNameTooLong); |
| } |
| } |
| |
| labelChanged(); |
| return status; |
| } |
| |
| /** |
| * Returns the building block label property value. |
| * |
| * @return the building block label property value. |
| */ |
| protected String getLabel() |
| { |
| String label; |
| if (defaultLabelButton.getSelection()) |
| { |
| label = ""; //$NON-NLS-1$ |
| } |
| else |
| { |
| label = labelText.getText(); |
| } |
| return label; |
| } |
| |
| /** |
| * Returns the building block model |
| * |
| * @return the building block model |
| */ |
| public BuildingBlockModel getBuildBlock() |
| { |
| return buildBlock; |
| } |
| |
| public void setBuildBlock(BuildingBlockModel buildBlock) |
| { |
| this.buildBlock = buildBlock; |
| } |
| |
| /* |
| * (non-Javadoc) |
| * |
| * @see org.eclipse.jdt.ui.wizards.NewTypeWizardPage#packageChanged() |
| */ |
| @Override |
| protected IStatus packageChanged() |
| { |
| IStatus superStatus = super.packageChanged(); |
| IStatus status = |
| new Status(superStatus.getSeverity(), CodeUtilsActivator.PLUGIN_ID, |
| superStatus.getMessage()); |
| |
| // The package name is being get by getPackageText because the method |
| // getPackageFragment |
| // (from super class) is not returning the right value in some cases |
| String packageName = getPackageText(); |
| |
| if (status.getCode() != IStatus.ERROR) |
| { |
| if (packageName != null) |
| { |
| Pattern pattern = Pattern.compile("[A-Za-z0-9_\\.]+"); //$NON-NLS-1$ |
| Matcher matcher = pattern.matcher(packageName); |
| |
| if (packageName.indexOf('.') == -1) |
| { |
| status = |
| new Status( |
| IStatus.ERROR, |
| CodeUtilsActivator.PLUGIN_ID, |
| CodeUtilsNLS.ERR_NewBuildingBlocksWizardPage_PackageMustHaveAtLeastTwoIdentifiers); |
| } |
| else if (!matcher.matches()) |
| { |
| String errMsg = |
| NLS.bind( |
| CodeUtilsNLS.ERR_NewBuildingBlocksWizardPage_InvalidPackageName, |
| packageName); |
| status = new Status(IStatus.ERROR, CodeUtilsActivator.PLUGIN_ID, errMsg); |
| } |
| else if (packageAndClassExist()) |
| { |
| status = |
| new Status( |
| IStatus.ERROR, |
| CodeUtilsActivator.PLUGIN_ID, |
| CodeUtilsNLS.ERR_NewBuildingBlocksWizardPage_PackageAndClassAlreadyExist); |
| } |
| else if (isTooLongOnFileSystem()) |
| { |
| status = |
| new Status(IStatus.ERROR, CodeUtilsActivator.PLUGIN_ID, |
| CodeUtilsNLS.ERR_NewBuildingBlocksWizardPage_FileNameTooLong); |
| } |
| } |
| |
| } |
| |
| return status; |
| } |
| |
| /* |
| * (non-Javadoc) |
| * |
| * @see org.eclipse.jdt.ui.wizards.NewTypeWizardPage#containerChanged() |
| */ |
| @Override |
| protected IStatus containerChanged() |
| { |
| IStatus superStatus = super.containerChanged(); |
| IStatus status = |
| new Status(superStatus.getSeverity(), CodeUtilsActivator.PLUGIN_ID, |
| superStatus.getMessage()); |
| |
| boolean hasNature = false; |
| |
| if (status.getCode() != IStatus.ERROR) |
| { |
| try |
| { |
| if ((getPackageFragmentRoot() != null) |
| && (getPackageFragmentRoot().getJavaProject() != null)) |
| { |
| hasNature = |
| getPackageFragmentRoot().getJavaProject().getProject() |
| .hasNature(IAndroidConstants.ANDROID_NATURE); |
| } |
| } |
| catch (CoreException ce) |
| { |
| StudioLogger.error(NewBuildingBlocksWizardPage.class, |
| "Error getting the project nature.", ce); //$NON-NLS-1$ |
| hasNature = false; |
| } |
| |
| if ((getPackageFragmentRoot() != null) && !hasNature) |
| { |
| status = |
| new Status(IStatus.ERROR, CodeUtilsActivator.PLUGIN_ID, |
| CodeUtilsNLS.ERR_NewBuildingBlocksWizardPage_SelectAnAndroidProject); |
| } |
| else if ((getPackageFragmentRoot() == null) |
| || (getPackageFragmentRoot().getResource().getType() == IResource.PROJECT) |
| || ((getPackageFragmentRoot().getElementType() & IPackageFragmentRoot.K_SOURCE) != IPackageFragmentRoot.K_SOURCE)) |
| { |
| status = |
| new Status( |
| IStatus.ERROR, |
| CodeUtilsActivator.PLUGIN_ID, |
| CodeUtilsNLS.ERR_NewBuildingBlocksWizardPage_SelectAValidSourceFolder); |
| } |
| else if (getPackageFragmentRoot().getElementName().equals( |
| IAndroidConstants.GEN_SRC_FOLDER) |
| && (getPackageFragmentRoot().getParent() instanceof IJavaProject)) |
| { |
| status = |
| new Status( |
| IStatus.ERROR, |
| CodeUtilsActivator.PLUGIN_ID, |
| CodeUtilsNLS.ERR_NewBuildingBlocksWizardPage_CannotUseTheGenFolderAsSourceFolder); |
| } |
| else if (isTooLongOnFileSystem()) |
| { |
| status = |
| new Status(IStatus.ERROR, CodeUtilsActivator.PLUGIN_ID, |
| CodeUtilsNLS.ERR_NewBuildingBlocksWizardPage_FileNameTooLong); |
| } |
| } |
| |
| return status; |
| } |
| |
| /** |
| * Checks for cross package/class collision among source folders |
| * |
| * @return true if there is any collision or false otherwise |
| */ |
| private boolean packageAndClassExist() |
| { |
| boolean exists = false; |
| |
| try |
| { |
| if ((getJavaProject() != null) && getJavaProject().isOpen()) |
| { |
| IPackageFragmentRoot[] roots = getJavaProject().getPackageFragmentRoots(); |
| |
| if (roots != null) |
| { |
| for (IPackageFragmentRoot root : roots) |
| { |
| if ((root.getKind() & IPackageFragmentRoot.K_SOURCE) == IPackageFragmentRoot.K_SOURCE) |
| { |
| IPackageFragment pack = root.getPackageFragment(getPackageText()); |
| |
| if ((pack != null) && pack.exists()) |
| { |
| IJavaElement classes[] = pack.getChildren(); |
| |
| if (classes != null) |
| { |
| for (IJavaElement clazz : classes) |
| { |
| if (clazz.getElementName().equals( |
| getTypeName() + JAVA_EXTENSION)) |
| { |
| exists = true; |
| break; |
| } |
| } |
| } |
| } |
| } |
| |
| if (exists) |
| { |
| break; |
| } |
| } |
| } |
| } |
| } |
| catch (JavaModelException e) |
| { |
| // Do nothing |
| StudioLogger.error(NewBuildingBlocksWizardPage.class, e.getLocalizedMessage(), e); |
| } |
| |
| return exists; |
| } |
| |
| /** |
| * Checks if the current building block that is being created can be written |
| * to the file system without throw a "file name too long" error |
| * |
| * @return true if the building block can be written or false otherwise |
| */ |
| private boolean isTooLongOnFileSystem() |
| { |
| boolean isTooLong = false; |
| |
| if (getPackageFragment() != null) |
| { |
| String javaFileName = |
| getPackageFragment().getCompilationUnit(getTypeName() + JAVA_EXTENSION) |
| .getResource().getLocation().toFile().getPath(); |
| |
| isTooLong = javaFileName.length() > MAX_PATH_SIZE; |
| } |
| |
| return isTooLong; |
| } |
| |
| /** |
| * Checks if the wizard can be opened. If the wizard cannot be opened, an |
| * error message is displayed. |
| * |
| * @return true if the wizard can be opened or false otherwise. |
| */ |
| private boolean canOpen() |
| { |
| boolean canOpen = true; |
| |
| if (getBuildBlock().getProject() != null) |
| { |
| IStatus status = null; |
| |
| try |
| { |
| AndroidManifestFile manifestFile = |
| AndroidProjectManifestFile.getFromProject(getBuildBlock().getProject()); |
| |
| if (manifestFile.hasErrors()) |
| { |
| status = |
| new MultiStatus( |
| CodeUtilsActivator.PLUGIN_ID, |
| IStatus.ERROR, |
| manifestFile.getErrors(), |
| CodeUtilsNLS.ERR_NewBuildingBlocksWizardPage_OneOrMoreErrorsWhenParsingManifest, |
| null); |
| } |
| } |
| catch (AndroidException e) |
| { |
| status = |
| new Status(IStatus.ERROR, CodeUtilsActivator.PLUGIN_ID, |
| e.getLocalizedMessage()); |
| } |
| catch (CoreException e) |
| { |
| status = e.getStatus(); |
| } |
| |
| if (status != null) |
| { |
| canOpen = false; |
| |
| EclipseUtils |
| .showErrorDialog( |
| CodeUtilsNLS.UI_GenericErrorDialogTitle, |
| CodeUtilsNLS.ERR_NewBuildingBlocksWizardPage_CannotProceedWithTheBuildingBlockCreation, |
| status); |
| } |
| } |
| |
| return canOpen; |
| } |
| } |