--- /dev/null
+/*******************************************************************************
+ * Copyright (c) 2000, 2011 IBM Corporation and others.
+ * All rights reserved. This program and the accompanying materials
+ * are made available under the terms of the Eclipse Public License v1.0
+ * which accompanies this distribution, and is available at
+ * http://www.eclipse.org/legal/epl-v10.html
+ *
+ * Contributors:
+ * IBM Corporation - initial API and implementation
+ *******************************************************************************/
+package org.eclipse.jdt.ui.wizards;
+
+import org.eclipse.swt.widgets.Composite;
+
+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.core.runtime.Path;
+
+import org.eclipse.core.resources.IProject;
+import org.eclipse.core.resources.IResource;
+import org.eclipse.core.resources.IWorkspaceRoot;
+import org.eclipse.core.resources.ResourcesPlugin;
+
+import org.eclipse.jface.viewers.ILabelProvider;
+import org.eclipse.jface.viewers.ISelection;
+import org.eclipse.jface.viewers.ISelectionProvider;
+import org.eclipse.jface.viewers.IStructuredSelection;
+import org.eclipse.jface.viewers.Viewer;
+import org.eclipse.jface.viewers.ViewerFilter;
+import org.eclipse.jface.window.Window;
+
+import org.eclipse.jface.text.ITextSelection;
+
+import org.eclipse.ui.IEditorPart;
+import org.eclipse.ui.IWorkbenchPart;
+import org.eclipse.ui.dialogs.ElementTreeSelectionDialog;
+import org.eclipse.ui.views.contentoutline.ContentOutline;
+
+import org.eclipse.jdt.core.IClasspathEntry;
+import org.eclipse.jdt.core.IJavaElement;
+import org.eclipse.jdt.core.IJavaModel;
+import org.eclipse.jdt.core.IJavaProject;
+import org.eclipse.jdt.core.IPackageFragmentRoot;
+import org.eclipse.jdt.core.JavaCore;
+import org.eclipse.jdt.core.JavaModelException;
+
+import org.eclipse.jdt.internal.corext.util.JavaModelUtil;
+import org.eclipse.jdt.internal.corext.util.Messages;
+
+import org.eclipse.jdt.ui.JavaElementComparator;
+import org.eclipse.jdt.ui.JavaElementLabelProvider;
+import org.eclipse.jdt.ui.StandardJavaElementContentProvider;
+
+import org.eclipse.jdt.internal.ui.JavaPlugin;
+import org.eclipse.jdt.internal.ui.dialogs.StatusInfo;
+import org.eclipse.jdt.internal.ui.viewsupport.BasicElementLabels;
+import org.eclipse.jdt.internal.ui.viewsupport.IViewPartInputProvider;
+import org.eclipse.jdt.internal.ui.wizards.NewWizardMessages;
+import org.eclipse.jdt.internal.ui.wizards.TypedElementSelectionValidator;
+import org.eclipse.jdt.internal.ui.wizards.TypedViewerFilter;
+import org.eclipse.jdt.internal.ui.wizards.dialogfields.DialogField;
+import org.eclipse.jdt.internal.ui.wizards.dialogfields.IDialogFieldListener;
+import org.eclipse.jdt.internal.ui.wizards.dialogfields.IStringButtonAdapter;
+import org.eclipse.jdt.internal.ui.wizards.dialogfields.LayoutUtil;
+import org.eclipse.jdt.internal.ui.wizards.dialogfields.StringButtonDialogField;
+
+/**
+ * Wizard page that acts as a base class for wizard pages that create new Java elements.
+ * The class provides a input field for source folders (called container in this class) and
+ * API to validate the enter source folder name.
+ *
+ * <p>
+ * Clients may subclass.
+ * </p>
+ *
+ * @since 2.0
+ */
+public abstract class NewContainerWizardPage extends NewElementWizardPage {
+
+ /** Id of the container field */
+ protected static final String CONTAINER= "NewContainerWizardPage.container"; //$NON-NLS-1$
+
+ /** The status of the last validation. */
+ protected IStatus fContainerStatus;
+
+ private StringButtonDialogField fContainerDialogField;
+
+ /*
+ * package fragment root corresponding to the input type (can be null)
+ */
+ private IPackageFragmentRoot fCurrRoot;
+
+ private IWorkspaceRoot fWorkspaceRoot;
+
+ /**
+ * Create a new <code>NewContainerWizardPage</code>
+ *
+ * @param name the wizard page's name
+ */
+ public NewContainerWizardPage(String name) {
+ super(name);
+ fWorkspaceRoot= ResourcesPlugin.getWorkspace().getRoot();
+ ContainerFieldAdapter adapter= new ContainerFieldAdapter();
+
+ fContainerDialogField= new StringButtonDialogField(adapter);
+ fContainerDialogField.setDialogFieldListener(adapter);
+ fContainerDialogField.setLabelText(getContainerLabel());
+ fContainerDialogField.setButtonLabel(NewWizardMessages.NewContainerWizardPage_container_button);
+
+ fContainerStatus= new StatusInfo();
+ fCurrRoot= null;
+ }
+
+ /**
+ * Returns the label that is used for the container input field.
+ *
+ * @return the label that is used for the container input field.
+ * @since 3.2
+ */
+ protected String getContainerLabel() {
+ return NewWizardMessages.NewContainerWizardPage_container_label;
+ }
+
+ /**
+ * Initializes the source folder field with a valid package fragment root.
+ * The package fragment root is computed from the given Java element.
+ *
+ * @param elem the Java element used to compute the initial package
+ * fragment root used as the source folder
+ */
+ protected void initContainerPage(IJavaElement elem) {
+ IPackageFragmentRoot initRoot= null;
+ if (elem != null) {
+ initRoot= JavaModelUtil.getPackageFragmentRoot(elem);
+ try {
+ if (initRoot == null || initRoot.getKind() != IPackageFragmentRoot.K_SOURCE) {
+ IJavaProject jproject= elem.getJavaProject();
+ if (jproject != null) {
+ initRoot= null;
+ if (jproject.exists()) {
+ IPackageFragmentRoot[] roots= jproject.getPackageFragmentRoots();
+ for (int i= 0; i < roots.length; i++) {
+ if (roots[i].getKind() == IPackageFragmentRoot.K_SOURCE) {
+ initRoot= roots[i];
+ break;
+ }
+ }
+ }
+ if (initRoot == null) {
+ initRoot= jproject.getPackageFragmentRoot(jproject.getResource());
+ }
+ }
+ }
+ } catch (JavaModelException e) {
+ JavaPlugin.log(e);
+ }
+ }
+ setPackageFragmentRoot(initRoot, true);
+ }
+
+ /**
+ * Utility method to inspect a selection to find a Java element.
+ *
+ * @param selection the selection to be inspected
+ * @return a Java element to be used as the initial selection, or <code>null</code>,
+ * if no Java element exists in the given selection
+ */
+ protected IJavaElement getInitialJavaElement(IStructuredSelection selection) {
+ IJavaElement jelem= null;
+ if (selection != null && !selection.isEmpty()) {
+ Object selectedElement= selection.getFirstElement();
+ if (selectedElement instanceof IAdaptable) {
+ IAdaptable adaptable= (IAdaptable) selectedElement;
+
+ jelem= (IJavaElement) adaptable.getAdapter(IJavaElement.class);
+ if (jelem == null || !jelem.exists()) {
+ jelem= null;
+ IResource resource= (IResource) adaptable.getAdapter(IResource.class);
+ if (resource != null && resource.getType() != IResource.ROOT) {
+ while (jelem == null && resource.getType() != IResource.PROJECT) {
+ resource= resource.getParent();
+ jelem= (IJavaElement) resource.getAdapter(IJavaElement.class);
+ }
+ if (jelem == null) {
+ jelem= JavaCore.create(resource); // java project
+ }
+ }
+ }
+ }
+ }
+ if (jelem == null) {
+ IWorkbenchPart part= JavaPlugin.getActivePage().getActivePart();
+ if (part instanceof ContentOutline) {
+ part= JavaPlugin.getActivePage().getActiveEditor();
+ }
+
+ if (part instanceof IViewPartInputProvider) {
+ Object elem= ((IViewPartInputProvider)part).getViewPartInput();
+ if (elem instanceof IJavaElement) {
+ jelem= (IJavaElement) elem;
+ }
+ }
+ }
+
+ if (jelem == null || jelem.getElementType() == IJavaElement.JAVA_MODEL) {
+ try {
+ IJavaProject[] projects= JavaCore.create(getWorkspaceRoot()).getJavaProjects();
+ if (projects.length == 1) {
+ IClasspathEntry[] rawClasspath= projects[0].getRawClasspath();
+ for (int i= 0; i < rawClasspath.length; i++) {
+ if (rawClasspath[i].getEntryKind() == IClasspathEntry.CPE_SOURCE) {// add only if the project contains a source folder
+ jelem= projects[0];
+ break;
+ }
+ }
+ }
+ } catch (JavaModelException e) {
+ JavaPlugin.log(e);
+ }
+ }
+ return jelem;
+ }
+
+ /**
+ * Returns the text selection of the current editor. <code>null</code> is returned
+ * when the current editor does not have focus or does not return a text selection.
+ * @return Returns the text selection of the current editor or <code>null</code>.
+ *
+ * @since 3.0
+ */
+ protected ITextSelection getCurrentTextSelection() {
+ IWorkbenchPart part= JavaPlugin.getActivePage().getActivePart();
+ if (part instanceof IEditorPart) {
+ ISelectionProvider selectionProvider= part.getSite().getSelectionProvider();
+ if (selectionProvider != null) {
+ ISelection selection= selectionProvider.getSelection();
+ if (selection instanceof ITextSelection) {
+ return (ITextSelection) selection;
+ }
+ }
+ }
+ return null;
+ }
+
+
+ /**
+ * Returns the recommended maximum width for text fields (in pixels). This
+ * method requires that createContent has been called before this method is
+ * call. Subclasses may override to change the maximum width for text
+ * fields.
+ *
+ * @return the recommended maximum width for text fields.
+ */
+ protected int getMaxFieldWidth() {
+ return convertWidthInCharsToPixels(40);
+ }
+
+
+ /**
+ * Creates the necessary controls (label, text field and browse button) to edit
+ * the source folder location. The method expects that the parent composite
+ * uses a <code>GridLayout</code> as its layout manager and that the
+ * grid layout has at least 3 columns.
+ *
+ * @param parent the parent composite
+ * @param nColumns the number of columns to span. This number must be
+ * greater or equal three
+ */
+ protected void createContainerControls(Composite parent, int nColumns) {
+ fContainerDialogField.doFillIntoGrid(parent, nColumns);
+ LayoutUtil.setWidthHint(fContainerDialogField.getTextControl(null), getMaxFieldWidth());
+ }
+
+ /**
+ * Sets the focus to the source folder's text field.
+ */
+ protected void setFocusOnContainer() {
+ fContainerDialogField.setFocus();
+ }
+
+ // -------- ContainerFieldAdapter --------
+
+ private class ContainerFieldAdapter implements IStringButtonAdapter, IDialogFieldListener {
+
+ // -------- IStringButtonAdapter
+ public void changeControlPressed(DialogField field) {
+ containerChangeControlPressed(field);
+ }
+
+ // -------- IDialogFieldListener
+ public void dialogFieldChanged(DialogField field) {
+ containerDialogFieldChanged(field);
+ }
+ }
+
+ private void containerChangeControlPressed(DialogField field) {
+ if (field == fContainerDialogField) {
+ // take the current jproject as init element of the dialog
+ IPackageFragmentRoot root= chooseContainer();
+ if (root != null) {
+ setPackageFragmentRoot(root, true);
+ }
+ }
+ }
+
+ private void containerDialogFieldChanged(DialogField field) {
+ if (field == fContainerDialogField) {
+ fContainerStatus= containerChanged();
+ }
+ // tell all others
+ handleFieldChanged(CONTAINER);
+ }
+
+ // ----------- validation ----------
+
+ /**
+ * This method is a hook which gets called after the source folder's
+ * text input field has changed. This default implementation updates
+ * the model and returns an error status. The underlying model
+ * is only valid if the returned status is OK.
+ *
+ * @return the model's error status
+ */
+ protected IStatus containerChanged() {
+ StatusInfo status= new StatusInfo();
+
+ fCurrRoot= null;
+ String str= getPackageFragmentRootText();
+ if (str.length() == 0) {
+ status.setError(NewWizardMessages.NewContainerWizardPage_error_EnterContainerName);
+ return status;
+ }
+ IPath path= new Path(str);
+ IResource res= fWorkspaceRoot.findMember(path);
+ if (res != null) {
+ int resType= res.getType();
+ if (resType == IResource.PROJECT || resType == IResource.FOLDER) {
+ IProject proj= res.getProject();
+ if (!proj.isOpen()) {
+ status.setError(Messages.format(NewWizardMessages.NewContainerWizardPage_error_ProjectClosed, BasicElementLabels.getPathLabel(proj.getFullPath(), false)));
+ return status;
+ }
+ IJavaProject jproject= JavaCore.create(proj);
+ fCurrRoot= jproject.getPackageFragmentRoot(res);
+ if (res.exists()) {
+ if (res.isVirtual()) {
+ status.setError(NewWizardMessages.NewContainerWizardPage_error_FolderIsVirtual);
+ return status;
+ }
+ try {
+ if (!proj.hasNature(JavaCore.NATURE_ID)) {
+ if (resType == IResource.PROJECT) {
+ status.setError(NewWizardMessages.NewContainerWizardPage_warning_NotAJavaProject);
+ } else {
+ status.setWarning(NewWizardMessages.NewContainerWizardPage_warning_NotInAJavaProject);
+ }
+ return status;
+ }
+ if (fCurrRoot.isArchive()) {
+ status.setError(Messages.format(NewWizardMessages.NewContainerWizardPage_error_ContainerIsBinary, BasicElementLabels.getPathLabel(path, false)));
+ return status;
+ }
+ if (fCurrRoot.getKind() == IPackageFragmentRoot.K_BINARY) {
+ status.setWarning(Messages.format(NewWizardMessages.NewContainerWizardPage_warning_inside_classfolder, BasicElementLabels.getPathLabel(path, false)));
+ } else if (!jproject.isOnClasspath(fCurrRoot)) {
+ status.setWarning(Messages.format(NewWizardMessages.NewContainerWizardPage_warning_NotOnClassPath, BasicElementLabels.getPathLabel(path, false)));
+ }
+ } catch (JavaModelException e) {
+ status.setWarning(NewWizardMessages.NewContainerWizardPage_warning_NotOnClassPath);
+ } catch (CoreException e) {
+ status.setWarning(NewWizardMessages.NewContainerWizardPage_warning_NotAJavaProject);
+ }
+ }
+ return status;
+ } else {
+ status.setError(Messages.format(NewWizardMessages.NewContainerWizardPage_error_NotAFolder, BasicElementLabels.getPathLabel(path, false)));
+ return status;
+ }
+ } else {
+ status.setError(Messages.format(NewWizardMessages.NewContainerWizardPage_error_ContainerDoesNotExist, BasicElementLabels.getPathLabel(path, false)));
+ return status;
+ }
+ }
+
+ // -------- update message ----------------
+
+ /**
+ * Hook method that gets called when a field on this page has changed. For this page the
+ * method gets called when the source folder field changes.
+ * <p>
+ * Every sub type is responsible to call this method when a field on its page has changed.
+ * Subtypes override (extend) the method to add verification when a own field has a
+ * dependency to an other field. For example the class name input must be verified
+ * again when the package field changes (check for duplicated class names).
+ *
+ * @param fieldName The name of the field that has changed (field id). For the
+ * source folder the field id is <code>CONTAINER</code>
+ */
+ protected void handleFieldChanged(String fieldName) {
+ }
+
+
+ // ---- get ----------------
+
+ /**
+ * Returns the workspace root.
+ *
+ * @return the workspace root
+ */
+ protected IWorkspaceRoot getWorkspaceRoot() {
+ return fWorkspaceRoot;
+ }
+
+ /**
+ * Returns the Java project of the currently selected package fragment root or <code>null</code>
+ * if no package fragment root is configured.
+ *
+ * @return The current Java project or <code>null</code>.
+ * @since 3.3
+ */
+ public IJavaProject getJavaProject() {
+ IPackageFragmentRoot root= getPackageFragmentRoot();
+ if (root != null) {
+ return root.getJavaProject();
+ }
+ return null;
+ }
+
+ /**
+ * Returns the <code>IPackageFragmentRoot</code> that corresponds to the current
+ * value of the source folder field.
+ *
+ * @return the IPackageFragmentRoot or <code>null</code> if the current source
+ * folder value is not a valid package fragment root
+ *
+ */
+ public IPackageFragmentRoot getPackageFragmentRoot() {
+ return fCurrRoot;
+ }
+
+ /**
+ * Returns the current text of source folder text field.
+ *
+ * @return the text of the source folder text field
+ */
+ public String getPackageFragmentRootText() {
+ return fContainerDialogField.getText();
+ }
+
+
+ /**
+ * Sets the current source folder (model and text field) to the given package
+ * fragment root.
+
+ * @param root The new root.
+ * @param canBeModified if <code>false</code> the source folder field can
+ * not be changed by the user. If <code>true</code> the field is editable
+ */
+ public void setPackageFragmentRoot(IPackageFragmentRoot root, boolean canBeModified) {
+ fCurrRoot= root;
+ String str= (root == null) ? "" : root.getPath().makeRelative().toString(); //$NON-NLS-1$
+ fContainerDialogField.setText(str);
+ fContainerDialogField.setEnabled(canBeModified);
+ }
+
+ // ------------- choose source container dialog
+
+ /**
+ * Opens a selection dialog that allows to select a source container.
+ *
+ * @return returns the selected package fragment root or <code>null</code> if the dialog has been canceled.
+ * The caller typically sets the result to the container input field.
+ * <p>
+ * Clients can override this method if they want to offer a different dialog.
+ * </p>
+ *
+ * @since 3.2
+ */
+ protected IPackageFragmentRoot chooseContainer() {
+ IJavaElement initElement= getPackageFragmentRoot();
+ Class<?>[] acceptedClasses= new Class[] { IPackageFragmentRoot.class, IJavaProject.class };
+ TypedElementSelectionValidator validator= new TypedElementSelectionValidator(acceptedClasses, false) {
+ @Override
+ public boolean isSelectedValid(Object element) {
+ try {
+ if (element instanceof IJavaProject) {
+ IJavaProject jproject= (IJavaProject)element;
+ IPath path= jproject.getProject().getFullPath();
+ return (jproject.findPackageFragmentRoot(path) != null);
+ } else if (element instanceof IPackageFragmentRoot) {
+ return (((IPackageFragmentRoot)element).getKind() == IPackageFragmentRoot.K_SOURCE);
+ }
+ return true;
+ } catch (JavaModelException e) {
+ JavaPlugin.log(e.getStatus()); // just log, no UI in validation
+ }
+ return false;
+ }
+ };
+
+ acceptedClasses= new Class[] { IJavaModel.class, IPackageFragmentRoot.class, IJavaProject.class };
+ ViewerFilter filter= new TypedViewerFilter(acceptedClasses) {
+ @Override
+ public boolean select(Viewer viewer, Object parent, Object element) {
+ if (element instanceof IPackageFragmentRoot) {
+ try {
+ return (((IPackageFragmentRoot)element).getKind() == IPackageFragmentRoot.K_SOURCE);
+ } catch (JavaModelException e) {
+ JavaPlugin.log(e.getStatus()); // just log, no UI in validation
+ return false;
+ }
+ }
+ return super.select(viewer, parent, element);
+ }
+ };
+
+ StandardJavaElementContentProvider provider= new StandardJavaElementContentProvider();
+ ILabelProvider labelProvider= new JavaElementLabelProvider(JavaElementLabelProvider.SHOW_DEFAULT);
+ ElementTreeSelectionDialog dialog= new ElementTreeSelectionDialog(getShell(), labelProvider, provider);
+ dialog.setValidator(validator);
+ dialog.setComparator(new JavaElementComparator());
+ dialog.setTitle(NewWizardMessages.NewContainerWizardPage_ChooseSourceContainerDialog_title);
+ dialog.setMessage(NewWizardMessages.NewContainerWizardPage_ChooseSourceContainerDialog_description);
+ dialog.addFilter(filter);
+ dialog.setInput(JavaCore.create(fWorkspaceRoot));
+ dialog.setInitialSelection(initElement);
+ dialog.setHelpAvailable(false);
+
+ if (dialog.open() == Window.OK) {
+ Object element= dialog.getFirstResult();
+ if (element instanceof IJavaProject) {
+ IJavaProject jproject= (IJavaProject)element;
+ return jproject.getPackageFragmentRoot(jproject.getProject());
+ } else if (element instanceof IPackageFragmentRoot) {
+ return (IPackageFragmentRoot)element;
+ }
+ return null;
+ }
+ return null;
+ }
+
+}
git://git.uio.no / ifi-stolz-refaktor.git / blobdiff