class creation wizard, implementation for dojo.
diff --git a/bundles/org.eclipse.wst.jsdt.web.ui/META-INF/MANIFEST.MF b/bundles/org.eclipse.wst.jsdt.web.ui/META-INF/MANIFEST.MF index 99d245e..095e2f3 100644 --- a/bundles/org.eclipse.wst.jsdt.web.ui/META-INF/MANIFEST.MF +++ b/bundles/org.eclipse.wst.jsdt.web.ui/META-INF/MANIFEST.MF
@@ -47,3 +47,5 @@ org.eclipse.wst.jsdt.manipulation;bundle-version="[1.0.0,2.0.0)" Eclipse-LazyStart: true Bundle-RequiredExecutionEnvironment: J2SE-1.4 +Import-Package: org.eclipse.core.filesystem, + org.eclipse.ui.views.contentoutline
diff --git a/bundles/org.eclipse.wst.jsdt.web.ui/icons/eye_icon.gif b/bundles/org.eclipse.wst.jsdt.web.ui/icons/eye_icon.gif new file mode 100644 index 0000000..078398e --- /dev/null +++ b/bundles/org.eclipse.wst.jsdt.web.ui/icons/eye_icon.gif Binary files differ
diff --git a/bundles/org.eclipse.wst.jsdt.web.ui/plugin.properties b/bundles/org.eclipse.wst.jsdt.web.ui/plugin.properties index fe0dbb7..5b067c8 100644 --- a/bundles/org.eclipse.wst.jsdt.web.ui/plugin.properties +++ b/bundles/org.eclipse.wst.jsdt.web.ui/plugin.properties
@@ -8,7 +8,8 @@ # Contributors: # IBM Corporation - initial API and implementation ############################################################################### - +wizard.name.0 = New Dojo Class +wizard.description.0 = Create a new Dojo JavaScript class Bundle-Vendor.0 = Eclipse.org Bundle-Name.0 = JSDT Web Support UI target.name.0 = JavaScirpt Source
diff --git a/bundles/org.eclipse.wst.jsdt.web.ui/plugin.xml b/bundles/org.eclipse.wst.jsdt.web.ui/plugin.xml index b7a3c36..c58ca51 100644 --- a/bundles/org.eclipse.wst.jsdt.web.ui/plugin.xml +++ b/bundles/org.eclipse.wst.jsdt.web.ui/plugin.xml
@@ -701,6 +701,21 @@ id="org.eclipse.wst.jsdt.internal.web.ui.convertProjects"> </action> </objectContribution> + </extension> + <extension + point="org.eclipse.ui.newWizards"> + <wizard + name="%wizard.name.0" + icon="/icons/eye_icon.gif" + category="org.eclipse.wst.jsdt.ui.java" + id="org.eclipse.wst.jsdt.ui.wizards.NewClassCreationWizard"> + <class class="org.eclipse.wst.jsdt.internal.ui.wizards.dojo.NewClassCreationWizard"> + <parameter name="javatype" value="true"/> + </class> + <description> + %wizard.description.0 + </description> + </wizard> </extension> <!-- Uncomment for Standalone + HTML as seperate options --> <!--
diff --git a/bundles/org.eclipse.wst.jsdt.web.ui/src/org/eclipse/wst/jsdt/internal/ui/wizards/dojo/NewClassCreationWizard.java b/bundles/org.eclipse.wst.jsdt.web.ui/src/org/eclipse/wst/jsdt/internal/ui/wizards/dojo/NewClassCreationWizard.java new file mode 100644 index 0000000..046e3f5 --- /dev/null +++ b/bundles/org.eclipse.wst.jsdt.web.ui/src/org/eclipse/wst/jsdt/internal/ui/wizards/dojo/NewClassCreationWizard.java
@@ -0,0 +1,88 @@ +package org.eclipse.wst.jsdt.internal.ui.wizards.dojo; + +import org.eclipse.core.resources.IFile; +import org.eclipse.core.resources.IResource; +import org.eclipse.core.runtime.CoreException; +import org.eclipse.core.runtime.IProgressMonitor; +import org.eclipse.wst.jsdt.core.IJavaScriptElement; +import org.eclipse.wst.jsdt.internal.ui.JavaScriptPlugin; +import org.eclipse.wst.jsdt.internal.ui.JavaPluginImages; +import org.eclipse.wst.jsdt.internal.ui.wizards.NewElementWizard; + +public class NewClassCreationWizard extends NewElementWizard { + + private NewClassWizardPage fPage; + private boolean fOpenEditorOnFinish; + + public NewClassCreationWizard() { + setDefaultPageImageDescriptor(JavaPluginImages.DESC_WIZBAN_NEWCLASS); + setDialogSettings(JavaScriptPlugin.getDefault().getDialogSettings()); + setWindowTitle("New Dojo Class"); + + fPage = null; + fOpenEditorOnFinish = true; + + } + + /* + * @see Wizard#createPages + */ + public void addPages() { + super.addPages(); + if (fPage == null) { + fPage = new NewClassWizardPage(); + fPage.init(getSelection()); + fPage.setWizard(this); + } + addPage(fPage); + } + + /* + * (non-Javadoc) + * + * @see org.eclipse.wst.jsdt.internal.ui.wizards.NewElementWizard#canRunForked() + */ + protected boolean canRunForked() { + return !fPage.isEnclosingTypeSelected(); + } + + /* + * (non-Javadoc) + * + * @see org.eclipse.wst.jsdt.internal.ui.wizards.NewElementWizard#finishPage(org.eclipse.core.runtime.IProgressMonitor) + */ + protected void finishPage(IProgressMonitor monitor) + throws InterruptedException, CoreException { + fPage.createType(monitor); // use the full progress monitor + } + + /* + * (non-Javadoc) + * + * @see org.eclipse.jface.wizard.IWizard#performFinish() + */ + public boolean performFinish() { + warnAboutTypeCommentDeprecation(); + boolean res = super.performFinish(); + if (res) { + IResource resource = fPage.getModifiedResource(); + if (resource != null) { + selectAndReveal(resource); + if (fOpenEditorOnFinish) { + openResource((IFile) resource); + } + } + } + return res; + } + + /* + * (non-Javadoc) + * + * @see org.eclipse.wst.jsdt.internal.ui.wizards.NewElementWizard#getCreatedElement() + */ + public IJavaScriptElement getCreatedElement() { + return fPage.getCreatedType(); + } + +}
diff --git a/bundles/org.eclipse.wst.jsdt.web.ui/src/org/eclipse/wst/jsdt/internal/ui/wizards/dojo/NewClassWizardPage.java b/bundles/org.eclipse.wst.jsdt.web.ui/src/org/eclipse/wst/jsdt/internal/ui/wizards/dojo/NewClassWizardPage.java new file mode 100644 index 0000000..87b1136 --- /dev/null +++ b/bundles/org.eclipse.wst.jsdt.web.ui/src/org/eclipse/wst/jsdt/internal/ui/wizards/dojo/NewClassWizardPage.java
@@ -0,0 +1,504 @@ +/******************************************************************************* + * Copyright (c) 2008 IBM Corporation and others. + * All rights reserved. + *******************************************************************************/ +package org.eclipse.wst.jsdt.internal.ui.wizards.dojo; + +import java.io.ByteArrayInputStream; +import java.io.IOException; + +import org.eclipse.core.resources.IFile; +import org.eclipse.core.runtime.CoreException; +import org.eclipse.core.runtime.IPath; +import org.eclipse.core.runtime.IProgressMonitor; +import org.eclipse.core.runtime.IStatus; +import org.eclipse.core.runtime.NullProgressMonitor; +import org.eclipse.core.runtime.Path; +import org.eclipse.core.runtime.Status; +import org.eclipse.jface.dialogs.Dialog; +import org.eclipse.jface.dialogs.IDialogSettings; +import org.eclipse.jface.viewers.IStructuredSelection; +import org.eclipse.swt.SWT; +import org.eclipse.swt.layout.GridLayout; +import org.eclipse.swt.widgets.Composite; +import org.eclipse.swt.widgets.Control; +import org.eclipse.ui.PlatformUI; +import org.eclipse.wst.jsdt.core.IJavaScriptProject; +import org.eclipse.wst.jsdt.core.IJavaScriptUnit; +import org.eclipse.wst.jsdt.internal.ui.IJavaHelpContextIds; +import org.eclipse.wst.jsdt.internal.ui.wizards.NewWizardMessages; +import org.eclipse.wst.jsdt.internal.ui.wizards.dialogfields.DialogField; +import org.eclipse.wst.jsdt.internal.ui.wizards.dialogfields.LayoutUtil; +import org.eclipse.wst.jsdt.internal.ui.wizards.dialogfields.SelectionButtonDialogFieldGroup; +import org.eclipse.wst.jsdt.web.core.javascript.IJsTranslation; +import org.eclipse.wst.jsdt.web.core.javascript.JsTranslationAdapter; +import org.eclipse.wst.jsdt.web.core.javascript.JsTranslationAdapterFactory; +import org.eclipse.wst.sse.core.StructuredModelManager; +import org.eclipse.wst.sse.core.internal.provisional.IStructuredModel; +import org.eclipse.wst.xml.core.internal.provisional.document.IDOMDocument; +import org.eclipse.wst.xml.core.internal.provisional.document.IDOMModel; + + +/** + * Wizard page to create a new class. + * <p> + * Note: This class is not intended to be subclassed, but clients can + * instantiate. To implement a different kind of a new class wizard page, extend + * <code>NewTypeWizardPage</code>. + * </p> + * + * @since 2.0 + */ +public class NewClassWizardPage extends NewTypeWizardPage { + + private final static String PAGE_NAME = "NewClassWizardPage"; //$NON-NLS-1$ + + private final static String SETTINGS_CREATEMAIN = "create_main"; //$NON-NLS-1$ + private final static String SETTINGS_CREATECONSTR = "create_constructor"; //$NON-NLS-1$ + private final static String SETTINGS_CREATEUNIMPLEMENTED = "create_unimplemented"; //$NON-NLS-1$ + + private SelectionButtonDialogFieldGroup fMethodStubsButtons; + + /** + * Creates a new <code>NewClassWizardPage</code> + */ + public NewClassWizardPage() { + super(true, PAGE_NAME); + + setTitle("Dojo Class"); + setDescription("Create a new Dojo Class"); + + // String[] buttonNames3= new String[] { + // NewWizardMessages.NewClassWizardPage_methods_main, + // NewWizardMessages.NewClassWizardPage_methods_constructors, + // NewWizardMessages.NewClassWizardPage_methods_inherited + // }; + String[] buttonNames3 = new String[] { "initializer", "statics" }; + fMethodStubsButtons = new SelectionButtonDialogFieldGroup(SWT.CHECK, + buttonNames3, 1); + fMethodStubsButtons + .setLabelText(NewWizardMessages.NewClassWizardPage_methods_label); + } + + // -------- Initialization --------- + + /** + * The wizard owning this page is responsible for calling this method with + * the current selection. The selection is used to initialize the fields of + * the wizard page. + * + * @param selection + * used to initialize the fields + */ + public void init(IStructuredSelection selection) { + getInitialJavaElement(selection); + // initContainerPage(jelem.getJavaProject()); + initContainerPage(selection); + initTypePage(selection); + doStatusUpdate(); + + boolean createMain = false; + boolean createConstructors = false; + boolean createUnimplemented = true; + IDialogSettings dialogSettings = getDialogSettings(); + if (dialogSettings != null) { + IDialogSettings section = dialogSettings.getSection(PAGE_NAME); + if (section != null) { + createMain = section.getBoolean(SETTINGS_CREATEMAIN); + createConstructors = section.getBoolean(SETTINGS_CREATECONSTR); + createUnimplemented = section + .getBoolean(SETTINGS_CREATEUNIMPLEMENTED); + } + } + + setMethodStubSelection(createMain, createConstructors, + createUnimplemented, true); + } + + // ------ validation -------- + protected void doStatusUpdate() { + // status of all used components + // IStatus[] status= new IStatus[] { + // fContainerStatus, + // isEnclosingTypeSelected() ? fEnclosingTypeStatus : fPackageStatus, + // fTypeNameStatus, + // fModifierStatus, + // fSuperClassStatus, + // fSuperInterfacesStatus + // }; + + // the mode severe status will be displayed and the OK button + // enabled/disabled. + String newFileName = getNewFileName(); + + String existingFileName = getExistingFileName(); + getFolderName(); + String className = getTypeName(); + getJavaProject(); + getExtends(); + boolean shouldUseExisting = shouldUseExisting(); + isCreateInit(); + isCreateStatic(); + + if (className == null || className.equals("")) { + updateStatus(new Status(IStatus.ERROR, "com.ibm.jsdt.dojo.core", + "Missing Class Name")); + } else if ((!shouldUseExisting) + && (newFileName == null || newFileName.equals(""))) { + updateStatus(new Status(IStatus.ERROR, "com.ibm.jsdt.dojo.core", + "No File Specified for new Class")); + + } else if ((shouldUseExisting) + && (existingFileName == null || existingFileName.equals(""))) { + updateStatus(new Status(IStatus.ERROR, "com.ibm.jsdt.dojo.core", + "No File Specified for new Class")); + } else { + + updateStatus(new Status(IStatus.OK, "com.ibm.jsdt.dojo.core", "")); + } + } + + /* + * @see NewContainerWizardPage#handleFieldChanged + */ + protected void handleFieldChanged(String fieldName) { + super.handleFieldChanged(fieldName); + + doStatusUpdate(); + } + + // ------ UI -------- + + /* + * @see WizardPage#createControl + */ + public void createControl(Composite parent) { + initializeDialogUnits(parent); + + Composite composite = new Composite(parent, SWT.NONE); + composite.setFont(parent.getFont()); + + int nColumns = 4; + + GridLayout layout = new GridLayout(); + layout.numColumns = nColumns; + composite.setLayout(layout); + + // pick & choose the wanted UI components + + createContainerControls(composite, nColumns); + createPackageControls(composite, nColumns); + createEnclosingTypeControls(composite, nColumns); + + createSeparator(composite, nColumns); + + createTypeNameControls(composite, nColumns); + // createModifierControls(composite, nColumns); + + // createSuperClassControls(composite, nColumns); + createSuperInterfacesControls(composite, nColumns); + + createMethodStubSelectionControls(composite, nColumns); + + // createCommentControls(composite, nColumns); + // enableCommentControl(true); + + setControl(composite); + + Dialog.applyDialogFont(composite); + PlatformUI.getWorkbench().getHelpSystem().setHelp(composite, + IJavaHelpContextIds.NEW_CLASS_WIZARD_PAGE); + } + + /* + * @see WizardPage#becomesVisible + */ + public void setVisible(boolean visible) { + super.setVisible(visible); + if (visible) { + setFocus(); + } else { + IDialogSettings dialogSettings = getDialogSettings(); + if (dialogSettings != null) { + IDialogSettings section = dialogSettings.getSection(PAGE_NAME); + if (section == null) { + section = dialogSettings.addNewSection(PAGE_NAME); + } + section.put(SETTINGS_CREATEMAIN, isCreateInit()); + section.put(SETTINGS_CREATECONSTR, isCreateStatic()); + + } + } + } + + private void createMethodStubSelectionControls(Composite composite, + int nColumns) { + Control labelControl = fMethodStubsButtons.getLabelControl(composite); + LayoutUtil.setHorizontalSpan(labelControl, nColumns); + + DialogField.createEmptySpace(composite); + + Control buttonGroup = fMethodStubsButtons + .getSelectionButtonsGroup(composite); + LayoutUtil.setHorizontalSpan(buttonGroup, nColumns - 1); + } + + /** + * Returns the current selection state of the 'Create Main' checkbox. + * + * @return the selection state of the 'Create Main' checkbox + */ + public boolean isCreateStatic() { + return fMethodStubsButtons.isSelected(1); + } + + /** + * Returns the current selection state of the 'Create Constructors' + * checkbox. + * + * @return the selection state of the 'Create Constructors' checkbox + */ + public boolean isCreateInit() { + return fMethodStubsButtons.isSelected(0); + } + + /** + * Sets the selection state of the method stub checkboxes. + * + * @param createMain + * initial selection state of the 'Create Main' checkbox. + * @param createConstructors + * initial selection state of the 'Create Constructors' checkbox. + * @param createInherited + * initial selection state of the 'Create inherited abstract + * methods' checkbox. + * @param canBeModified + * if <code>true</code> the method stub checkboxes can be + * changed by the user. If <code>false</code> the buttons are + * "read-only" + */ + public void setMethodStubSelection(boolean createMain, + boolean createConstructors, boolean createInherited, + boolean canBeModified) { + fMethodStubsButtons.setSelection(0, createMain); + fMethodStubsButtons.setSelection(1, createConstructors); + fMethodStubsButtons.setSelection(2, createInherited); + + fMethodStubsButtons.setEnabled(canBeModified); + } + + // // ---- creation ---------------- + // + // /* + // * @see NewTypeWizardPage#createTypeMembers + // */ + // protected void createTypeMembers(IType type, ImportsManager imports, + // IProgressMonitor monitor) throws CoreException { + // boolean doMain= isCreateMain(); + // boolean doConstr= isCreateConstructors(); + // boolean doInherited= isCreateInherited(); + // createInheritedMethods(type, doConstr, doInherited, imports, new + // SubProgressMonitor(monitor, 1)); + // + // if (doMain) { + // StringBuffer buf= new StringBuffer(); + // final String lineDelim= "\n"; // OK, since content is formatted afterwards + // //$NON-NLS-1$ + // String comment= CodeGeneration.getMethodComment(type.getCompilationUnit(), + // type.getTypeQualifiedName('.'), "main", new String[] {"args"}, new String[0], + // Signature.createTypeSignature("void", true), null, lineDelim); //$NON-NLS-1$ + // //$NON-NLS-2$ //$NON-NLS-3$ + // if (comment != null) { + // buf.append(comment); + // buf.append(lineDelim); + // } + // buf.append("public static void main("); //$NON-NLS-1$ + // buf.append(imports.addImport("java.lang.String")); //$NON-NLS-1$ + // buf.append("[] args) {"); //$NON-NLS-1$ + // buf.append(lineDelim); + // final String content= + // CodeGeneration.getMethodBodyContent(type.getCompilationUnit(), + // type.getTypeQualifiedName('.'), "main", false, "", lineDelim); //$NON-NLS-1$ + // //$NON-NLS-2$ + // if (content != null && content.length() != 0) + // buf.append(content); + // buf.append(lineDelim); + // buf.append("}"); //$NON-NLS-1$ + // type.createMethod(buf.toString(), null, false, null); + // } + // + // if (monitor != null) { + // monitor.done(); + // } + // } + public void createType(IProgressMonitor monitor) throws CoreException, + InterruptedException { + if (monitor == null) { + monitor = new NullProgressMonitor(); + } + + monitor.beginTask("Create Dojo Class...", 8); + + String newFileName = getNewFileName(); + String existingFileName = getExistingFileName(); + String newPath = getFolderName(); + String className = getTypeName(); + IJavaScriptProject project = getJavaProject(); + String[] extendedClasses = getExtends(); + boolean shouldUseExisting = shouldUseExisting(); + boolean shouldCreateInit = isCreateInit(); + boolean shouldCreateStatic = isCreateStatic(); + // boolean shouldGenerateComments = isAddComments(); + String typeText1 = ""; + String typeText2 = ""; + String typeText3 = ""; + String typeText4 = ""; + String typeText5 = ""; + + typeText1 = "dojo.declare(\"" + className + "\""; + + /* Build the mixins in the typeText2 string */ + if (extendedClasses != null && extendedClasses.length > 0) { + typeText1 += ","; + } + + if (extendedClasses != null && extendedClasses.length > 1) { + typeText2 += "["; + } + for (int i = 0; extendedClasses != null && i < extendedClasses.length; i++) { + typeText2 += extendedClasses[i]; + if (i < extendedClasses.length - 1) + typeText2 += ","; + } + if (extendedClasses != null && extendedClasses.length > 1) { + typeText2 += "]"; + } + + /* Start the class body */ + + typeText3 += ",{\n\t/* Class Body */\n\n"; + + if (shouldCreateInit) { + typeText4 += "\tinitializer: function() {\n\t/* Class Initializer */\n\n\t}"; + + } + + if (shouldCreateInit && shouldCreateStatic) { + typeText4 += ","; + } + + if (shouldCreateStatic) { + typeText4 += "\n\tstatics: {\n\t\t /* declare static variables and functions here */\n\n\t}\n"; + + } + + typeText5 += "});"; + + String typeText = typeText1 + typeText2 + typeText3 + typeText4 + + typeText5; + + if (shouldUseExisting) { + + String fileExtension = (new Path(existingFileName)) + .getFileExtension(); + + if (fileExtension != null && fileExtension.equalsIgnoreCase(".js")) { + + if (existingFileName.length() > 0 + && existingFileName.charAt(0) == '/' + || existingFileName.charAt(0) == '\\') { + existingFileName = existingFileName.substring(1); + } + /* Create type in an existing file */ + IJavaScriptUnit jElm = (IJavaScriptUnit) project + .findElement(new Path(existingFileName)); + + if (jElm == null) + return; + + jElm.becomeWorkingCopy(monitor); + jElm.getBuffer().append(typeText); + jElm.commitWorkingCopy(true, monitor); + jElm.discardWorkingCopy(); + } else if (fileExtension != null + && (fileExtension.equalsIgnoreCase("html") + || fileExtension.equalsIgnoreCase("htm") || fileExtension + .equalsIgnoreCase("jsp"))) { + /* handle dojo class creation in an html file */ + IFile toHtml = project.getProject().getFile(existingFileName); + insertInThml(toHtml, typeText); + + } + } else { + /* Create the type in a new file */ + IPath newFilePath = new Path(newPath + "/" + newFileName); + IFile theFile = project.getProject().getFile(newFilePath); + + String fileExtension = theFile.getFileExtension(); + + if (fileExtension != null + && (fileExtension.equalsIgnoreCase("html") + || fileExtension.equalsIgnoreCase("htm") || fileExtension + .equalsIgnoreCase("jsp"))) { + /* a little special casing for HTML/JSP */ + typeText = "<html>\n<head>\n<script>\n" + typeText + + "\n</script>\n</head>\n</html>"; + + } + ByteArrayInputStream str = new ByteArrayInputStream(typeText + .getBytes()); + theFile.create(str, true, monitor); + + } + + } + + private void insertInThml(IFile htmlFile, String text) { + boolean existing = true; + IDOMModel xmlModel = null; + try { + xmlModel = (IDOMModel) StructuredModelManager.getModelManager() + .getExistingModelForEdit(htmlFile); + if (xmlModel == null) { + try { + existing = false; + xmlModel = (IDOMModel) StructuredModelManager + .getModelManager().getModelForEdit(htmlFile); + } catch (IOException ex) { + // TODO Auto-generated catch block + ex.printStackTrace(); + } catch (CoreException ex) { + // TODO Auto-generated catch block + ex.printStackTrace(); + } + } + if (!existing) + JsTranslationAdapterFactory.setupAdapterFactory(xmlModel); + IDOMDocument xmlDoc = xmlModel.getDocument(); + + JsTranslationAdapter fTranslationAdapter = (JsTranslationAdapter) xmlDoc + .getAdapterFor(IJsTranslation.class); + if (fTranslationAdapter != null) { + IJsTranslation translation = fTranslationAdapter + .getJSPTranslation(false); + translation.insertInFirstScriptRegion(text); + + } + if (!existing) + removeAdapterFactory(xmlModel); + } finally { + if (xmlModel != null) + xmlModel.releaseFromEdit(); + + } + + } + + + + private void removeAdapterFactory(IStructuredModel sm) { + if (sm.getFactoryRegistry().getFactoryFor(IJsTranslation.class) != null) { + sm.getFactoryRegistry().removeFactoriesFor(IJsTranslation.class); + } + } +}
diff --git a/bundles/org.eclipse.wst.jsdt.web.ui/src/org/eclipse/wst/jsdt/internal/ui/wizards/dojo/NewContainerWizardPage.java b/bundles/org.eclipse.wst.jsdt.web.ui/src/org/eclipse/wst/jsdt/internal/ui/wizards/dojo/NewContainerWizardPage.java new file mode 100644 index 0000000..450ae20 --- /dev/null +++ b/bundles/org.eclipse.wst.jsdt.web.ui/src/org/eclipse/wst/jsdt/internal/ui/wizards/dojo/NewContainerWizardPage.java
@@ -0,0 +1,235 @@ +/******************************************************************************* + * Copyright (c) 2008 IBM Corporation and others. + * All rights reserved. + *******************************************************************************/ +package org.eclipse.wst.jsdt.internal.ui.wizards.dojo; + +import org.eclipse.core.resources.IResource; +import org.eclipse.core.resources.IWorkspaceRoot; +import org.eclipse.core.resources.ResourcesPlugin; +import org.eclipse.core.runtime.IAdaptable; +import org.eclipse.core.runtime.IStatus; +import org.eclipse.jface.viewers.IStructuredSelection; +import org.eclipse.swt.widgets.Composite; +import org.eclipse.ui.IWorkbenchPart; +import org.eclipse.ui.views.contentoutline.ContentOutline; +import org.eclipse.wst.jsdt.core.IJavaScriptElement; +import org.eclipse.wst.jsdt.core.IJavaScriptProject; +import org.eclipse.wst.jsdt.core.JavaScriptCore; +import org.eclipse.wst.jsdt.core.JavaScriptModelException; +import org.eclipse.wst.jsdt.internal.ui.JavaScriptPlugin; +import org.eclipse.wst.jsdt.internal.ui.viewsupport.IViewPartInputProvider; +import org.eclipse.wst.jsdt.internal.ui.wizards.dialogfields.DialogField; +import org.eclipse.wst.jsdt.internal.ui.wizards.dialogfields.IDialogFieldListener; +import org.eclipse.wst.jsdt.internal.ui.wizards.dialogfields.LayoutUtil; +import org.eclipse.wst.jsdt.internal.ui.wizards.dialogfields.StringDialogField; +import org.eclipse.wst.jsdt.ui.wizards.NewElementWizardPage; + +/** + * 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 StringDialogField fNewFileName; + + private IJavaScriptProject fJavaProject; + + 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(); + fNewFileName = new StringDialogField();// new + // StringButtonDialogField(adapter); + fNewFileName.setLabelText("New File Name"); + fNewFileName.setDialogFieldListener(new IDialogFieldListener() { + + public void dialogFieldChanged(DialogField field) { + doStatusUpdate(); + + } + + }); + // fContainerDialogField.setButtonLabel("Br&owse"); + + // fContainerStatus= new StatusInfo(); + // fCurrRoot= null; + } + + protected void doStatusUpdate() { + + } + + protected void shouldDisableFolderSelection(boolean enabled) { + fNewFileName.setEnabled(enabled); + } + + /** + * 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(IStructuredSelection selection) { + IJavaScriptElement initialElement = getInitialJavaElement(selection); + + fJavaProject = initialElement != null ? initialElement.getJavaScriptProject() + : null; + fNewFileName.setEnabled(true); + fNewFileName.setFocus(); + } + + /** + * 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 IJavaScriptElement getInitialJavaElement(IStructuredSelection selection) { + IJavaScriptElement jelem = null; + if (selection != null && !selection.isEmpty()) { + Object selectedElement = selection.getFirstElement(); + if (selectedElement instanceof IAdaptable) { + IAdaptable adaptable = (IAdaptable) selectedElement; + + jelem = (IJavaScriptElement) adaptable.getAdapter(IJavaScriptElement.class); + if (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 = (IJavaScriptElement) resource + .getAdapter(IJavaScriptElement.class); + } + if (jelem == null) { + jelem = JavaScriptCore.create(resource); // java project + } + } + } + } + } + if (jelem == null) { + IWorkbenchPart part = JavaScriptPlugin.getActivePage().getActivePart(); + if (part instanceof ContentOutline) { + part = JavaScriptPlugin.getActivePage().getActiveEditor(); + } + + if (part instanceof IViewPartInputProvider) { + Object elem = ((IViewPartInputProvider) part) + .getViewPartInput(); + if (elem instanceof IJavaScriptElement) { + jelem = (IJavaScriptElement) elem; + } + } + } + + if (jelem == null || jelem.getElementType() == IJavaScriptElement.JAVASCRIPT_MODEL) { + try { + IJavaScriptProject[] projects = JavaScriptCore.create(getWorkspaceRoot()) + .getJavaScriptProjects(); + if (projects.length == 1) { + jelem = projects[0]; + } + } catch (JavaScriptModelException e) { + JavaScriptPlugin.log(e); + } + } + return jelem; + } + + /** + * 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) { + fNewFileName.doFillIntoGrid(parent, nColumns); + LayoutUtil.setWidthHint(fNewFileName.getTextControl(null), + getMaxFieldWidth()); + + } + + /** + * Sets the focus to the source folder's text field. + */ + protected void setFocusOnContainer() { + fNewFileName.setFocus(); + } + + /** + * 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 IJavaScriptProject getJavaProject() { + return fJavaProject; + } + + public void setJavaProject(IJavaScriptProject project) { + fJavaProject = project; + } + + protected String getNewFileName() { + return fNewFileName.getText(); + } + +}
diff --git a/bundles/org.eclipse.wst.jsdt.web.ui/src/org/eclipse/wst/jsdt/internal/ui/wizards/dojo/NewTypeWizardPage.java b/bundles/org.eclipse.wst.jsdt.web.ui/src/org/eclipse/wst/jsdt/internal/ui/wizards/dojo/NewTypeWizardPage.java new file mode 100644 index 0000000..5a4bbaf --- /dev/null +++ b/bundles/org.eclipse.wst.jsdt.web.ui/src/org/eclipse/wst/jsdt/internal/ui/wizards/dojo/NewTypeWizardPage.java
@@ -0,0 +1,2567 @@ +/******************************************************************************* + * Copyright (c) 2008 IBM Corporation and others. + * All rights reserved. + * + *******************************************************************************/ +package org.eclipse.wst.jsdt.internal.ui.wizards.dojo; + +import java.lang.reflect.InvocationTargetException; +import java.net.URI; +import java.util.ArrayList; +import java.util.HashSet; +import java.util.Iterator; +import java.util.List; +import java.util.Set; + + +import org.eclipse.core.filesystem.EFS; +import org.eclipse.core.filesystem.IFileStore; +import org.eclipse.core.resources.IFile; +import org.eclipse.core.resources.IFolder; +import org.eclipse.core.resources.IProject; +import org.eclipse.core.resources.IResource; +import org.eclipse.core.runtime.CoreException; +import org.eclipse.core.runtime.IProgressMonitor; +import org.eclipse.core.runtime.IStatus; +import org.eclipse.core.runtime.NullProgressMonitor; +import org.eclipse.core.runtime.Status; +import org.eclipse.core.runtime.SubProgressMonitor; +import org.eclipse.jface.contentassist.SubjectControlContentAssistant; +import org.eclipse.jface.dialogs.MessageDialog; +import org.eclipse.jface.operation.IRunnableWithProgress; +import org.eclipse.jface.preference.PreferenceDialog; +import org.eclipse.jface.text.BadLocationException; +import org.eclipse.jface.text.templates.Template; +import org.eclipse.jface.text.templates.TemplateException; +import org.eclipse.jface.viewers.CellEditor; +import org.eclipse.jface.viewers.ICellModifier; +import org.eclipse.jface.viewers.ILabelProvider; +import org.eclipse.jface.viewers.ISelection; +import org.eclipse.jface.viewers.IStructuredSelection; +import org.eclipse.jface.viewers.ITreeContentProvider; +import org.eclipse.jface.viewers.LabelProvider; +import org.eclipse.jface.viewers.TableViewer; +import org.eclipse.jface.viewers.ViewerFilter; +import org.eclipse.jface.window.Window; +import org.eclipse.swt.SWT; +import org.eclipse.swt.accessibility.AccessibleAdapter; +import org.eclipse.swt.accessibility.AccessibleEvent; +import org.eclipse.swt.events.KeyAdapter; +import org.eclipse.swt.events.KeyEvent; +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.Composite; +import org.eclipse.swt.widgets.Item; +import org.eclipse.swt.widgets.Link; +import org.eclipse.swt.widgets.Text; +import org.eclipse.text.edits.TextEdit; +import org.eclipse.ui.contentassist.ContentAssistHandler; +import org.eclipse.ui.dialogs.ISelectionStatusValidator; +import org.eclipse.ui.dialogs.PreferencesUtil; +import org.eclipse.ui.model.WorkbenchContentProvider; +import org.eclipse.ui.model.WorkbenchLabelProvider; +import org.eclipse.wst.jsdt.core.Flags; +import org.eclipse.wst.jsdt.core.IJavaScriptUnit; +import org.eclipse.wst.jsdt.core.IJavaScriptElement; +import org.eclipse.wst.jsdt.core.IJavaScriptProject; +import org.eclipse.wst.jsdt.core.IFunction; +import org.eclipse.wst.jsdt.core.IPackageFragment; +import org.eclipse.wst.jsdt.core.IType; +import org.eclipse.wst.jsdt.core.JavaScriptConventions; +import org.eclipse.wst.jsdt.core.JavaScriptCore; +import org.eclipse.wst.jsdt.core.compiler.IProblem; +import org.eclipse.wst.jsdt.core.dom.AST; +import org.eclipse.wst.jsdt.core.dom.ASTParser; +import org.eclipse.wst.jsdt.core.dom.JavaScriptUnit; +import org.eclipse.wst.jsdt.core.dom.ITypeBinding; +import org.eclipse.wst.jsdt.core.dom.rewrite.ImportRewrite; +import org.eclipse.wst.jsdt.core.search.IJavaScriptSearchConstants; +import org.eclipse.wst.jsdt.core.search.IJavaScriptSearchScope; +import org.eclipse.wst.jsdt.core.search.SearchEngine; +import org.eclipse.wst.jsdt.internal.corext.codemanipulation.AddUnimplementedConstructorsOperation; +import org.eclipse.wst.jsdt.internal.corext.codemanipulation.AddUnimplementedMethodsOperation; +import org.eclipse.wst.jsdt.internal.corext.dom.ASTNodes; +import org.eclipse.wst.jsdt.internal.corext.refactoring.StubTypeContext; +import org.eclipse.wst.jsdt.internal.corext.refactoring.TypeContextChecker; +import org.eclipse.wst.jsdt.internal.corext.template.java.JavaContext; +import org.eclipse.wst.jsdt.internal.corext.util.JavaModelUtil; +import org.eclipse.wst.jsdt.internal.corext.util.Messages; +import org.eclipse.wst.jsdt.internal.corext.util.Resources; +import org.eclipse.wst.jsdt.internal.ui.JavaScriptPlugin; +import org.eclipse.wst.jsdt.internal.ui.JavaPluginImages; +import org.eclipse.wst.jsdt.internal.ui.dialogs.FilteredTypesSelectionDialog; +import org.eclipse.wst.jsdt.internal.ui.dialogs.StatusInfo; +import org.eclipse.wst.jsdt.internal.ui.dialogs.TableTextCellEditor; +import org.eclipse.wst.jsdt.internal.ui.dialogs.TextFieldNavigationHandler; +import org.eclipse.wst.jsdt.internal.ui.preferences.CodeTemplatePreferencePage; +import org.eclipse.wst.jsdt.internal.ui.preferences.JavaPreferencesSettings; +import org.eclipse.wst.jsdt.internal.ui.refactoring.contentassist.CompletionContextRequestor; +import org.eclipse.wst.jsdt.internal.ui.refactoring.contentassist.ControlContentAssistHelper; +import org.eclipse.wst.jsdt.internal.ui.refactoring.contentassist.JavaPackageCompletionProcessor; +import org.eclipse.wst.jsdt.internal.ui.refactoring.contentassist.JavaTypeCompletionProcessor; +import org.eclipse.wst.jsdt.internal.ui.util.SWTUtil; +import org.eclipse.wst.jsdt.internal.ui.wizards.NewWizardMessages; +import org.eclipse.wst.jsdt.internal.ui.wizards.TypedViewerFilter; +import org.eclipse.wst.jsdt.internal.ui.wizards.buildpaths.FolderSelectionDialog; +import org.eclipse.wst.jsdt.internal.ui.wizards.dialogfields.DialogField; +import org.eclipse.wst.jsdt.internal.ui.wizards.dialogfields.IDialogFieldListener; +import org.eclipse.wst.jsdt.internal.ui.wizards.dialogfields.IListAdapter; +import org.eclipse.wst.jsdt.internal.ui.wizards.dialogfields.IStringButtonAdapter; +import org.eclipse.wst.jsdt.internal.ui.wizards.dialogfields.LayoutUtil; +import org.eclipse.wst.jsdt.internal.ui.wizards.dialogfields.ListDialogField; +import org.eclipse.wst.jsdt.internal.ui.wizards.dialogfields.SelectionButtonDialogField; +import org.eclipse.wst.jsdt.internal.ui.wizards.dialogfields.SelectionButtonDialogFieldGroup; +import org.eclipse.wst.jsdt.internal.ui.wizards.dialogfields.Separator; +import org.eclipse.wst.jsdt.internal.ui.wizards.dialogfields.StringButtonDialogField; +import org.eclipse.wst.jsdt.internal.ui.wizards.dialogfields.StringButtonStatusDialogField; +import org.eclipse.wst.jsdt.internal.ui.wizards.dialogfields.StringDialogField; +import org.eclipse.wst.jsdt.ui.CodeStyleConfiguration; +import org.eclipse.wst.jsdt.ui.wizards.NewInterfaceWizardPage; + +/** + * The class <code>NewTypeWizardPage</code> contains controls and validation + * routines for a 'New Type WizardPage'. Implementors decide which components to + * add and to enable. Implementors can also customize the validation code. + * <code>NewTypeWizardPage</code> is intended to serve as base class of all + * wizards that create types like applets, servlets, classes, interfaces, etc. + * <p> + * See {@link NewClassWizardPage} or {@link NewInterfaceWizardPage} for an + * example usage of the <code>NewTypeWizardPage</code>. + * </p> + * + * @see org.eclipse.wst.jsdt.ui.wizards.NewClassWizardPage + * @see org.eclipse.wst.jsdt.ui.wizards.NewInterfaceWizardPage + * @see org.eclipse.wst.jsdt.ui.wizards.NewEnumWizardPage + * @see org.eclipse.wst.jsdt.ui.wizards.NewAnnotationWizardPage + * + * @since 2.0 + */ +public abstract class NewTypeWizardPage extends NewContainerWizardPage { + + /** + * Class used in stub creation routines to add needed imports to a + * compilation unit. + */ + public static class ImportsManager { + + private ImportRewrite fImportsRewrite; + + /* package */ImportsManager(JavaScriptUnit astRoot) + throws CoreException { + fImportsRewrite = CodeStyleConfiguration.createImportRewrite( + astRoot, true); + } + + /* package */IJavaScriptUnit getCompilationUnit() { + return fImportsRewrite.getCompilationUnit(); + } + + /** + * Adds a new import declaration that is sorted in the existing imports. + * If an import already exists or the import would conflict with an + * import of an other type with the same simple name, the import is not + * added. + * + * @param qualifiedTypeName + * The fully qualified name of the type to import (dot + * separated). + * @return Returns the simple type name that can be used in the code or + * the fully qualified type name if an import conflict prevented + * the import. + */ + public String addImport(String qualifiedTypeName) { + return fImportsRewrite.addImport(qualifiedTypeName); + } + + /** + * Adds a new import declaration that is sorted in the existing imports. + * If an import already exists or the import would conflict with an + * import of an other type with the same simple name, the import is not + * added. + * + * @param typeBinding + * the binding of the type to import + * + * @return Returns the simple type name that can be used in the code or + * the fully qualified type name if an import conflict prevented + * the import. + */ + public String addImport(ITypeBinding typeBinding) { + return fImportsRewrite.addImport(typeBinding); + } + + /** + * Adds a new import declaration for a static type that is sorted in the + * existing imports. If an import already exists or the import would + * conflict with an import of an other static import with the same + * simple name, the import is not added. + * + * @param declaringTypeName + * The qualified name of the static's member declaring type + * @param simpleName + * the simple name of the member; either a field or a method + * name. + * @param isField + * <code>true</code> specifies that the member is a field, + * <code>false</code> if it is a method. + * @return returns either the simple member name if the import was + * successful or else the qualified name if an import conflict + * prevented the import. + * + * @since 3.2 + */ + public String addStaticImport(String declaringTypeName, + String simpleName, boolean isField) { + return fImportsRewrite.addStaticImport(declaringTypeName, + simpleName, isField); + } + + /* package */void create(boolean needsSave, IProgressMonitor monitor) + throws CoreException { + TextEdit edit = fImportsRewrite.rewriteImports(monitor); + JavaModelUtil.applyEdit(fImportsRewrite.getCompilationUnit(), edit, + needsSave, null); + } + + /* package */void removeImport(String qualifiedName) { + fImportsRewrite.removeImport(qualifiedName); + } + + /* package */void removeStaticImport(String qualifiedName) { + fImportsRewrite.removeStaticImport(qualifiedName); + } + } + + /** + * Public access flag. See The Java Virtual Machine Specification for more + * details. + */ + public int F_PUBLIC = Flags.AccPublic; + /** + * Private access flag. See The Java Virtual Machine Specification for more + * details. + */ + public int F_PRIVATE = Flags.AccPrivate; + /** + * Protected access flag. See The Java Virtual Machine Specification for + * more details. + */ + public int F_PROTECTED = Flags.AccProtected; + /** + * Static access flag. See The Java Virtual Machine Specification for more + * details. + */ + public int F_STATIC = Flags.AccStatic; + /** + * Final access flag. See The Java Virtual Machine Specification for more + * details. + */ + public int F_FINAL = Flags.AccFinal; + /** + * Abstract property flag. See The Java Virtual Machine Specification for + * more details. + */ + public int F_ABSTRACT = Flags.AccAbstract; + + private final static String PAGE_NAME = "NewTypeWizardPage"; //$NON-NLS-1$ + + /** Field ID of the package input field. */ + protected final static String PACKAGE = PAGE_NAME + ".package"; //$NON-NLS-1$ + /** Field ID of the enclosing type input field. */ + protected final static String ENCLOSING = PAGE_NAME + ".enclosing"; //$NON-NLS-1$ + /** Field ID of the enclosing type checkbox. */ + protected final static String ENCLOSINGSELECTION = ENCLOSING + ".selection"; //$NON-NLS-1$ + /** Field ID of the type name input field. */ + protected final static String TYPENAME = PAGE_NAME + ".typename"; //$NON-NLS-1$ + /** Field ID of the super type input field. */ + protected final static String SUPER = PAGE_NAME + ".superclass"; //$NON-NLS-1$ + /** Field ID of the super interfaces input field. */ + protected final static String INTERFACES = PAGE_NAME + ".interfaces"; //$NON-NLS-1$ + /** Field ID of the modifier check boxes. */ + protected final static String MODIFIERS = PAGE_NAME + ".modifiers"; //$NON-NLS-1$ + /** Field ID of the method stubs check boxes. */ + protected final static String METHODS = PAGE_NAME + ".methods"; //$NON-NLS-1$ + + private static class InterfaceWrapper { + public String interfaceName; + + public InterfaceWrapper(String interfaceName) { + this.interfaceName = interfaceName; + } + + public int hashCode() { + return interfaceName.hashCode(); + } + + public boolean equals(Object obj) { + return obj != null + && getClass().equals(obj.getClass()) + && ((InterfaceWrapper) obj).interfaceName + .equals(interfaceName); + } + } + + private static class InterfacesListLabelProvider extends LabelProvider { + private Image fInterfaceImage; + + public InterfacesListLabelProvider() { + fInterfaceImage = JavaPluginImages + .get(JavaPluginImages.IMG_OBJS_CLASS); + } + + public String getText(Object element) { + return ((InterfaceWrapper) element).interfaceName; + } + + public Image getImage(Object element) { + return fInterfaceImage; + } + } + + private StringButtonStatusDialogField fFolderName; + + private SelectionButtonDialogField fUseExistingFileTick; + private StringButtonDialogField fExistingFileName; + + private IPackageFragment fCurrPackage; + + private IType fCurrEnclosingType; + /** + * a handle to the type to be created (does usually not exist, can be null) + */ + private IType fCurrType; + private StringDialogField fTypeNameDialogField; + + private StringButtonDialogField fSuperClassDialogField; + private ListDialogField fSuperInterfacesDialogField; + + private SelectionButtonDialogFieldGroup fAccMdfButtons; + private SelectionButtonDialogFieldGroup fOtherMdfButtons; + + private IType fCreatedType; + + private JavaPackageCompletionProcessor fCurrPackageCompletionProcessor; + private JavaTypeCompletionProcessor fEnclosingTypeCompletionProcessor; + private StubTypeContext fSuperClassStubTypeContext; + private StubTypeContext fSuperInterfaceStubTypeContext; + + private final int PUBLIC_INDEX = 0, DEFAULT_INDEX = 1, PRIVATE_INDEX = 2, + PROTECTED_INDEX = 3; + private final int ABSTRACT_INDEX = 0, FINAL_INDEX = 1, STATIC_INDEX = 2, + ENUM_ANNOT_STATIC_INDEX = 1; + + private int fTypeKind; + + /** + * Constant to signal that the created type is a class. + * + * @since 3.1 + */ + public static final int CLASS_TYPE = 1; + + /** + * Constant to signal that the created type is a interface. + * + * @since 3.1 + */ + public static final int INTERFACE_TYPE = 2; + + /** + * Constant to signal that the created type is an enum. + * + * @since 3.1 + */ + public static final int ENUM_TYPE = 3; + + /** + * Constant to signal that the created type is an annotation. + * + * @since 3.1 + */ + public static final int ANNOTATION_TYPE = 4; + + /** + * Creates a new <code>NewTypeWizardPage</code>. + * + * @param isClass + * <code>true</code> if a new class is to be created; otherwise + * an interface is to be created + * @param pageName + * the wizard page's name + */ + public NewTypeWizardPage(boolean isClass, String pageName) { + this(isClass ? CLASS_TYPE : INTERFACE_TYPE, pageName); + } + + /** + * Creates a new <code>NewTypeWizardPage</code>. + * + * @param typeKind + * Signals the kind of the type to be created. Valid kinds are + * {@link #CLASS_TYPE}, {@link #INTERFACE_TYPE}, + * {@link #ENUM_TYPE} and {@link #ANNOTATION_TYPE} + * @param pageName + * the wizard page's name + * @since 3.1 + */ + public NewTypeWizardPage(int typeKind, String pageName) { + super(pageName); + fTypeKind = typeKind; + + fCreatedType = null; + + TypeFieldsAdapter adapter = new TypeFieldsAdapter(); + + fFolderName = new StringButtonStatusDialogField(adapter); + fFolderName.setDialogFieldListener(adapter); + fFolderName.setLabelText("Folder"); + fFolderName + .setButtonLabel(NewWizardMessages.NewTypeWizardPage_package_button); + // fPackageDialogField.setStatusWidthHint(NewWizardMessages.NewTypeWizardPage_default); + + fUseExistingFileTick = new SelectionButtonDialogField(SWT.CHECK); + fUseExistingFileTick.setDialogFieldListener(adapter); + fUseExistingFileTick.setLabelText("Existing File"); + + fExistingFileName = new StringButtonDialogField(adapter); + fExistingFileName.setDialogFieldListener(adapter); + fExistingFileName + .setButtonLabel(NewWizardMessages.NewTypeWizardPage_enclosing_button); + + fTypeNameDialogField = new StringDialogField(); + fTypeNameDialogField.setDialogFieldListener(adapter); + fTypeNameDialogField.setLabelText(getTypeNameLabel()); + + fSuperClassDialogField = new StringButtonDialogField(adapter); + fSuperClassDialogField.setDialogFieldListener(adapter); + fSuperClassDialogField.setLabelText("Super Class"); + fSuperClassDialogField + .setButtonLabel(NewWizardMessages.NewTypeWizardPage_superclass_button); + + String[] addButtons = new String[] { + NewWizardMessages.NewTypeWizardPage_interfaces_add, + /* 1 */null, + NewWizardMessages.NewTypeWizardPage_interfaces_remove }; + fSuperInterfacesDialogField = new ListDialogField(adapter, addButtons, + new InterfacesListLabelProvider()); + fSuperInterfacesDialogField.setDialogFieldListener(adapter); + fSuperInterfacesDialogField + .setTableColumns(new ListDialogField.ColumnsDescription(1, + false)); + fSuperInterfacesDialogField.setLabelText(getSuperInterfacesLabel()); + fSuperInterfacesDialogField.setRemoveButtonIndex(2); + + String[] buttonNames1 = new String[] { + NewWizardMessages.NewTypeWizardPage_modifiers_public, + NewWizardMessages.NewTypeWizardPage_modifiers_default, + NewWizardMessages.NewTypeWizardPage_modifiers_private, + NewWizardMessages.NewTypeWizardPage_modifiers_protected }; + fAccMdfButtons = new SelectionButtonDialogFieldGroup(SWT.RADIO, + buttonNames1, 4); + fAccMdfButtons.setDialogFieldListener(adapter); + fAccMdfButtons.setLabelText(getModifiersLabel()); + fAccMdfButtons.setSelection(0, true); + + String[] buttonNames2; + if (fTypeKind == CLASS_TYPE) { + buttonNames2 = new String[] { + NewWizardMessages.NewTypeWizardPage_modifiers_abstract, + NewWizardMessages.NewTypeWizardPage_modifiers_final, + NewWizardMessages.NewTypeWizardPage_modifiers_static }; + } else { + if (fTypeKind == ENUM_TYPE || fTypeKind == ANNOTATION_TYPE) { + buttonNames2 = new String[] { + NewWizardMessages.NewTypeWizardPage_modifiers_abstract, + NewWizardMessages.NewTypeWizardPage_modifiers_static }; + } else + buttonNames2 = new String[] {}; + } + + fOtherMdfButtons = new SelectionButtonDialogFieldGroup(SWT.CHECK, + buttonNames2, 4); + fOtherMdfButtons.setDialogFieldListener(adapter); + + fAccMdfButtons.enableSelectionButton(PRIVATE_INDEX, false); + fAccMdfButtons.enableSelectionButton(PROTECTED_INDEX, false); + fOtherMdfButtons.enableSelectionButton(STATIC_INDEX, false); + + if (fTypeKind == ENUM_TYPE || fTypeKind == ANNOTATION_TYPE) { + fOtherMdfButtons.enableSelectionButton(ABSTRACT_INDEX, false); + fOtherMdfButtons.enableSelectionButton(ENUM_ANNOT_STATIC_INDEX, + false); + } + + // fAddCommentButton= new SelectionButtonDialogField(SWT.CHECK); + // fAddCommentButton.setLabelText(NewWizardMessages.NewTypeWizardPage_addcomment_label); + + updateEnableState(); + + } + + /** + * Initializes all fields provided by the page with a given selection. + * + * @param elem + * the selection used to initialize this page or <code> + * null</code> + * if no selection was available + */ + protected void initTypePage(IStructuredSelection selection) { + ArrayList initSuperinterfaces = new ArrayList(5); + + Object o = selection.getFirstElement(); + + String initFolder = null; + String initFile = null; + + if (o instanceof IFolder) { + initFolder = ((IFolder) o).getProjectRelativePath().toString(); + } else if (o instanceof IFile) { + // initFolder = + // ((IFile)o).getProjectRelativePath().removeLastSegments(1).toString(); + initFile = ((IFile) o).getProjectRelativePath().toString(); + setEnclosingTypeSelection(true, false); + + } + + if (initFile == null && initFolder != null) + fFolderName.setText(initFolder); + if (initFile != null) { + fExistingFileName.setText(initFile); + + } + // if (elem != null) { + // // evaluate the enclosing type + // project= elem.getJavaProject(); + // pack= (IPackageFragment) elem.getAncestor(IJavaScriptElement.PACKAGE_FRAGMENT); + // IType typeInCU= (IType) elem.getAncestor(IJavaScriptElement.TYPE); + // if (typeInCU != null) { + // if (typeInCU.getCompilationUnit() != null) { + // enclosingType= typeInCU; + // } + // } else { + // IJavaScriptUnit cu= (IJavaScriptUnit) + // elem.getAncestor(IJavaScriptElement.COMPILATION_UNIT); + // if (cu != null) { + // enclosingType= cu.findPrimaryType(); + // } + // } + // + // try { + // IType type= null; + // if (elem.getElementType() == IJavaScriptElement.TYPE) { + // type= (IType)elem; + // if (type.exists()) { + // String superName= JavaModelUtil.getFullyQualifiedName(type); + // if (type.isInterface()) { + // initSuperinterfaces.add(superName); + // } else { + // initSuperclass= superName; + // } + // } + // } + // } catch (JavaScriptModelException e) { + // JavaScriptPlugin.log(e); + // // ignore this exception now + // } + // } + + // setTypeName(typeName, true); + // setSuperClass(initSuperclass, true); + setSuperInterfaces(initSuperinterfaces, true); + + // setAddComments(StubUtility.doAddComments(project), true); // from project + // or workspace + } + + private static IStatus validateJavaTypeName(String text, + IJavaScriptProject project) { + if (project == null || !project.exists()) { + return JavaScriptConventions.validateJavaScriptTypeName(text, + JavaScriptCore.VERSION_1_3, JavaScriptCore.VERSION_1_3); + } + String sourceLevel = project.getOption(JavaScriptCore.COMPILER_SOURCE, true); + String compliance = project.getOption(JavaScriptCore.COMPILER_COMPLIANCE, + true); + return JavaScriptConventions.validateJavaScriptTypeName(text, sourceLevel, + compliance); + } + + /** + * Returns the label that is used for the type name input field. + * + * @return the label that is used for the type name input field. + * @since 3.2 + */ + protected String getTypeNameLabel() { + return NewWizardMessages.NewTypeWizardPage_typename_label; + } + + /** + * Returns the label that is used for the modifiers input field. + * + * @return the label that is used for the modifiers input field + * @since 3.2 + */ + protected String getModifiersLabel() { + return NewWizardMessages.NewTypeWizardPage_modifiers_acc_label; + } + + /** + * Returns the label that is used for the super interfaces input field. + * + * @return the label that is used for the super interfaces input field. + * @since 3.2 + */ + protected String getSuperInterfacesLabel() { + return "Super Types:"; + // if (fTypeKind != INTERFACE_TYPE) + // return NewWizardMessages.NewTypeWizardPage_interfaces_class_label; + // return NewWizardMessages.NewTypeWizardPage_interfaces_ifc_label; + } + + /** + * Creates a separator line. Expects a <code>GridLayout</code> with at + * least 1 column. + * + * @param composite + * the parent composite + * @param nColumns + * number of columns to span + */ + protected void createSeparator(Composite composite, int nColumns) { + (new Separator(SWT.SEPARATOR | SWT.HORIZONTAL)).doFillIntoGrid( + composite, nColumns, convertHeightInCharsToPixels(1)); + } + + /** + * Creates the controls for the package name field. Expects a + * <code>GridLayout</code> with at least 4 columns. + * + * @param composite + * the parent composite + * @param nColumns + * number of columns to span + */ + protected void createPackageControls(Composite composite, int nColumns) { + fFolderName.doFillIntoGrid(composite, nColumns); + Text text = fFolderName.getTextControl(null); + LayoutUtil.setWidthHint(text, getMaxFieldWidth()); + LayoutUtil.setHorizontalGrabbing(text); + ControlContentAssistHelper.createTextContentAssistant(text, + fCurrPackageCompletionProcessor); + TextFieldNavigationHandler.install(text); + } + + /** + * Creates the controls for the enclosing type name field. Expects a + * <code>GridLayout</code> with at least 4 columns. + * + * @param composite + * the parent composite + * @param nColumns + * number of columns to span + */ + protected void createEnclosingTypeControls(Composite composite, int nColumns) { + // #6891 + Composite tabGroup = new Composite(composite, SWT.NONE); + GridLayout layout = new GridLayout(); + layout.marginWidth = 0; + layout.marginHeight = 0; + tabGroup.setLayout(layout); + + fUseExistingFileTick.doFillIntoGrid(tabGroup, 1); + + Text text = fExistingFileName.getTextControl(composite); + text.getAccessible().addAccessibleListener(new AccessibleAdapter() { + public void getName(AccessibleEvent e) { + e.result = NewWizardMessages.NewTypeWizardPage_enclosing_field_description; + } + }); + GridData gd = new GridData(GridData.FILL_HORIZONTAL); + gd.widthHint = getMaxFieldWidth(); + gd.horizontalSpan = 2; + text.setLayoutData(gd); + + Button button = fExistingFileName.getChangeControl(composite); + gd = new GridData(GridData.HORIZONTAL_ALIGN_FILL); + gd.widthHint = SWTUtil.getButtonWidthHint(button); + button.setLayoutData(gd); + ControlContentAssistHelper.createTextContentAssistant(text, + fEnclosingTypeCompletionProcessor); + TextFieldNavigationHandler.install(text); + } + + /** + * Creates the controls for the type name field. Expects a + * <code>GridLayout</code> with at least 2 columns. + * + * @param composite + * the parent composite + * @param nColumns + * number of columns to span + */ + protected void createTypeNameControls(Composite composite, int nColumns) { + fTypeNameDialogField.doFillIntoGrid(composite, nColumns - 1); + DialogField.createEmptySpace(composite); + + Text text = fTypeNameDialogField.getTextControl(null); + LayoutUtil.setWidthHint(text, getMaxFieldWidth()); + TextFieldNavigationHandler.install(text); + } + + /** + * Creates the controls for the modifiers radio/checkbox buttons. Expects a + * <code>GridLayout</code> with at least 3 columns. + * + * @param composite + * the parent composite + * @param nColumns + * number of columns to span + */ + // protected void createModifierControls(Composite composite, int nColumns) { + // LayoutUtil.setHorizontalSpan(fAccMdfButtons.getLabelControl(composite), 1); + // + // Control control= fAccMdfButtons.getSelectionButtonsGroup(composite); + // GridData gd= new GridData(GridData.HORIZONTAL_ALIGN_FILL); + // gd.horizontalSpan= nColumns - 2; + // control.setLayoutData(gd); + // + // DialogField.createEmptySpace(composite); + // + // if (fTypeKind == CLASS_TYPE) { + // DialogField.createEmptySpace(composite); + // + // control= fOtherMdfButtons.getSelectionButtonsGroup(composite); + // gd= new GridData(GridData.HORIZONTAL_ALIGN_FILL); + // gd.horizontalSpan= nColumns - 2; + // control.setLayoutData(gd); + // + // DialogField.createEmptySpace(composite); + // } + // } + /** + * Creates the controls for the superclass name field. Expects a + * <code>GridLayout</code> with at least 3 columns. + * + * @param composite + * the parent composite + * @param nColumns + * number of columns to span + */ + protected void createSuperClassControls(Composite composite, int nColumns) { + fSuperClassDialogField.doFillIntoGrid(composite, nColumns); + Text text = fSuperClassDialogField.getTextControl(null); + LayoutUtil.setWidthHint(text, getMaxFieldWidth()); + + JavaTypeCompletionProcessor superClassCompletionProcessor = new JavaTypeCompletionProcessor( + false, false, true); + superClassCompletionProcessor + .setCompletionContextRequestor(new CompletionContextRequestor() { + public StubTypeContext getStubTypeContext() { + return getSuperClassStubTypeContext(); + } + }); + + ControlContentAssistHelper.createTextContentAssistant(text, + superClassCompletionProcessor); + TextFieldNavigationHandler.install(text); + } + + /** + * Creates the controls for the superclass name field. Expects a + * <code>GridLayout</code> with at least 3 columns. + * + * @param composite + * the parent composite + * @param nColumns + * number of columns to span + */ + protected void createSuperInterfacesControls(Composite composite, + int nColumns) { + final String INTERFACE = "Super Classes"; //$NON-NLS-1$ + fSuperInterfacesDialogField.doFillIntoGrid(composite, nColumns); + final TableViewer tableViewer = fSuperInterfacesDialogField + .getTableViewer(); + tableViewer.setColumnProperties(new String[] { INTERFACE }); + + TableTextCellEditor cellEditor = new TableTextCellEditor(tableViewer, 0) { + protected void doSetFocus() { + if (text != null) { + text.setFocus(); + text.setSelection(text.getText().length()); + checkSelection(); + checkDeleteable(); + checkSelectable(); + } + } + }; + JavaTypeCompletionProcessor superInterfaceCompletionProcessor = new JavaTypeCompletionProcessor( + false, false, true); + superInterfaceCompletionProcessor + .setCompletionContextRequestor(new CompletionContextRequestor() { + public StubTypeContext getStubTypeContext() { + return getSuperInterfacesStubTypeContext(); + } + }); + SubjectControlContentAssistant contentAssistant = ControlContentAssistHelper + .createJavaContentAssistant(superInterfaceCompletionProcessor); + Text cellEditorText = cellEditor.getText(); + ContentAssistHandler.createHandlerForText(cellEditorText, + contentAssistant); + TextFieldNavigationHandler.install(cellEditorText); + cellEditor.setContentAssistant(contentAssistant); + + tableViewer.setCellEditors(new CellEditor[] { cellEditor }); + tableViewer.setCellModifier(new ICellModifier() { + public void modify(Object element, String property, Object value) { + if (element instanceof Item) + element = ((Item) element).getData(); + + ((InterfaceWrapper) element).interfaceName = (String) value; + fSuperInterfacesDialogField.elementChanged(element); + } + + public Object getValue(Object element, String property) { + return ((InterfaceWrapper) element).interfaceName; + } + + public boolean canModify(Object element, String property) { + return true; + } + }); + tableViewer.getTable().addKeyListener(new KeyAdapter() { + public void keyPressed(KeyEvent event) { + if (event.keyCode == SWT.F2 && event.stateMask == 0) { + ISelection selection = tableViewer.getSelection(); + if (!(selection instanceof IStructuredSelection)) + return; + IStructuredSelection structuredSelection = (IStructuredSelection) selection; + tableViewer.editElement(structuredSelection + .getFirstElement(), 0); + } + } + }); + GridData gd = (GridData) fSuperInterfacesDialogField.getListControl( + null).getLayoutData(); + if (fTypeKind == CLASS_TYPE) { + gd.heightHint = convertHeightInCharsToPixels(3); + } else { + gd.heightHint = convertHeightInCharsToPixels(6); + } + gd.grabExcessVerticalSpace = false; + gd.widthHint = getMaxFieldWidth(); + } + + /** + * Creates the controls for the preference page links. Expects a + * <code>GridLayout</code> with at least 3 columns. + * + * @param composite + * the parent composite + * @param nColumns + * number of columns to span + * + * @since 3.1 + */ + protected void createCommentControls(Composite composite, int nColumns) { + Link link = new Link(composite, SWT.NONE); + link + .setText(NewWizardMessages.NewTypeWizardPage_addcomment_description); + link.addSelectionListener(new TypeFieldsAdapter()); + link.setLayoutData(new GridData(GridData.FILL, GridData.CENTER, false, + false, nColumns, 1)); + DialogField.createEmptySpace(composite); + // fAddCommentButton.doFillIntoGrid(composite, nColumns - 1); + } + + /** + * Sets the focus on the type name input field. + */ + protected void setFocus() { + fTypeNameDialogField.setFocus(); + } + + // -------- TypeFieldsAdapter -------- + + private class TypeFieldsAdapter implements IStringButtonAdapter, + IDialogFieldListener, IListAdapter, SelectionListener { + + // -------- IStringButtonAdapter + public void changeControlPressed(DialogField field) { + typePageChangeControlPressed(field); + } + + // -------- IListAdapter + public void customButtonPressed(ListDialogField field, int index) { + typePageCustomButtonPressed(field, index); + } + + public void selectionChanged(ListDialogField field) { + } + + // -------- IDialogFieldListener + public void dialogFieldChanged(DialogField field) { + typePageDialogFieldChanged(field); + } + + public void doubleClicked(ListDialogField field) { + } + + public void widgetSelected(SelectionEvent e) { + typePageLinkActivated(e); + } + + public void widgetDefaultSelected(SelectionEvent e) { + typePageLinkActivated(e); + } + } + + private void typePageLinkActivated(SelectionEvent e) { + IJavaScriptProject project = getJavaProject(); + if (project != null) { + PreferenceDialog dialog = PreferencesUtil.createPropertyDialogOn( + getShell(), project.getProject(), + CodeTemplatePreferencePage.PROP_ID, null, null); + dialog.open(); + } else { + String title = NewWizardMessages.NewTypeWizardPage_configure_templates_title; + String message = NewWizardMessages.NewTypeWizardPage_configure_templates_message; + MessageDialog.openInformation(getShell(), title, message); + } + } + + private void typePageChangeControlPressed(DialogField field) { + if (field == fFolderName) { + IResource pack = chooseFolder(); + if (pack != null) { + fFolderName.setText(pack.getName()); + } + } else if (field == fExistingFileName) { + IResource type = chooseExistingFile(); + if (type != null) { + String pathInWorkspace = type.getProjectRelativePath() + .toString(); + fExistingFileName.setText(pathInWorkspace); + } + } else if (field == fSuperClassDialogField) { + IType type = chooseSuperClass(); + if (type != null) { + fSuperClassDialogField.setText(JavaModelUtil + .getFullyQualifiedName(type)); + } + } + } + + private void typePageCustomButtonPressed(DialogField field, int index) { + if (field == fSuperInterfacesDialogField) { + chooseSuperInterfaces(); + List interfaces = fSuperInterfacesDialogField.getElements(); + if (!interfaces.isEmpty()) { + Object element = interfaces.get(interfaces.size() - 1); + fSuperInterfacesDialogField.editElement(element); + } + } + } + + /* + * A field on the type has changed. The fields' status and all dependent + * status are updated. + */ + private void typePageDialogFieldChanged(DialogField field) { + String fieldName = null; + if (field == fFolderName) { + packageChanged(); + updatePackageStatusLabel(); + typeNameChanged(); + superClassChanged(); + fieldName = PACKAGE; + } else if (field == fExistingFileName) { + enclosingTypeChanged(); + typeNameChanged(); + superClassChanged(); + // fieldName= ENCLOSING; + } else if (field == fUseExistingFileTick) { + updateEnableState(); + boolean isEnclosedType = isEnclosingTypeSelected(); + shouldDisableFolderSelection(!isEnclosedType); + if (!isEnclosedType) { + if (fAccMdfButtons.isSelected(PRIVATE_INDEX) + || fAccMdfButtons.isSelected(PROTECTED_INDEX)) { + fAccMdfButtons.setSelection(PRIVATE_INDEX, false); + fAccMdfButtons.setSelection(PROTECTED_INDEX, false); + fAccMdfButtons.setSelection(PUBLIC_INDEX, true); + } + if (fOtherMdfButtons.isSelected(STATIC_INDEX)) { + fOtherMdfButtons.setSelection(STATIC_INDEX, false); + } + } + fAccMdfButtons.enableSelectionButton(PRIVATE_INDEX, isEnclosedType); + fAccMdfButtons.enableSelectionButton(PROTECTED_INDEX, + isEnclosedType); + fOtherMdfButtons + .enableSelectionButton(STATIC_INDEX, isEnclosedType); + typeNameChanged(); + superClassChanged(); + fieldName = ENCLOSINGSELECTION; + } else if (field == fTypeNameDialogField) { + typeNameChanged(); + // fieldName= TYPENAME; + } else if (field == fSuperClassDialogField) { + // fSuperClassStatus= superClassChanged(); + // fieldName= SUPER; + } else if (field == fSuperInterfacesDialogField) { + // fSuperInterfacesStatus= superInterfacesChanged(); + // fieldName= INTERFACES; + } else if (field == fOtherMdfButtons || field == fAccMdfButtons) { + modifiersChanged(); + fieldName = MODIFIERS; + } else { + // fieldName= METHODS; + } + // tell all others + handleFieldChanged(fieldName); + } + + // -------- update message ---------------- + + /* + * @see org.eclipse.wst.jsdt.ui.wizards.NewContainerWizardPage#handleFieldChanged(String) + */ + protected void handleFieldChanged(String fieldName) { + + if (fieldName == CONTAINER) { + enclosingTypeChanged(); + + } + } + + // ---- set / get ---------------- + + /** + * Returns the text of the package input field. + * + * @return the text of the package input field + */ + public String getPackageText() { + return fFolderName.getText(); + } + + /** + * Returns the text of the enclosing type input field. + * + * @return the text of the enclosing type input field + */ + public String getEnclosingTypeText() { + return fExistingFileName.getText(); + } + + /** + * Returns the package fragment corresponding to the current input. + * + * @return a package fragment or <code>null</code> if the input could not + * be resolved. + */ + public IPackageFragment getPackageFragment() { + if (!isEnclosingTypeSelected()) { + return fCurrPackage; + } else { + if (fCurrEnclosingType != null) { + return fCurrEnclosingType.getPackageFragment(); + } + } + return null; + } + + /** + * Sets the package fragment to the given value. The method updates the + * model and the text of the control. + * + * @param pack + * the package fragment to be set + * @param canBeModified + * if <code>true</code> the package fragment is editable; + * otherwise it is read-only. + */ + // public void setPackageFragment(IPackageFragment pack, boolean canBeModified) + // { + // fCurrPackage= pack; + // fCanModifyPackage= canBeModified; + // String str= (pack == null) ? "" : pack.getElementName(); //$NON-NLS-1$ + // fFolderName.setText(str); + // updateEnableState(); + // } + /** + * Returns the enclosing type corresponding to the current input. + * + * @return the enclosing type or <code>null</code> if the enclosing type + * is not selected or the input could not be resolved + */ + public IType getEnclosingType() { + if (isEnclosingTypeSelected()) { + return fCurrEnclosingType; + } + return null; + } + + /** + * Sets the enclosing type. The method updates the underlying model and the + * text of the control. + * + * @param type + * the enclosing type + * @param canBeModified + * if <code>true</code> the enclosing type field is editable; + * otherwise it is read-only. + */ + public void setEnclosingType(IType type, boolean canBeModified) { + fCurrEnclosingType = type; + String str = (type == null) ? "" : JavaModelUtil.getFullyQualifiedName(type); //$NON-NLS-1$ + fExistingFileName.setText(str); + updateEnableState(); + } + + /** + * Returns the selection state of the enclosing type checkbox. + * + * @return the selection state of the enclosing type checkbox + */ + public boolean isEnclosingTypeSelected() { + return fUseExistingFileTick.isSelected(); + } + + /** + * Sets the enclosing type checkbox's selection state. + * + * @param isSelected + * the checkbox's selection state + * @param canBeModified + * if <code>true</code> the enclosing type checkbox is + * modifiable; otherwise it is read-only. + */ + public void setEnclosingTypeSelection(boolean isSelected, + boolean canBeModified) { + fUseExistingFileTick.setSelection(isSelected); + fUseExistingFileTick.setEnabled(canBeModified); + updateEnableState(); + } + + /** + * Returns the type name entered into the type input field. + * + * @return the type name + */ + public String getTypeName() { + return fTypeNameDialogField.getText(); + } + + /** + * Sets the type name input field's text to the given value. Method doesn't + * update the model. + * + * @param name + * the new type name + * @param canBeModified + * if <code>true</code> the type name field is editable; + * otherwise it is read-only. + */ + public void setTypeName(String name, boolean canBeModified) { + fTypeNameDialogField.setText(name); + fTypeNameDialogField.setEnabled(canBeModified); + } + + /** + * Returns the selected modifiers. + * + * @return the selected modifiers + * @see Flags + */ + public int getModifiers() { + int mdf = 0; + if (fAccMdfButtons.isSelected(PUBLIC_INDEX)) { + mdf += F_PUBLIC; + } else if (fAccMdfButtons.isSelected(PRIVATE_INDEX)) { + mdf += F_PRIVATE; + } else if (fAccMdfButtons.isSelected(PROTECTED_INDEX)) { + mdf += F_PROTECTED; + } + if (fOtherMdfButtons.isSelected(ABSTRACT_INDEX)) { + mdf += F_ABSTRACT; + } + if (fOtherMdfButtons.isSelected(FINAL_INDEX)) { + mdf += F_FINAL; + } + if (fOtherMdfButtons.isSelected(STATIC_INDEX)) { + mdf += F_STATIC; + } + return mdf; + } + + /** + * Sets the modifiers. + * + * @param modifiers + * <code>F_PUBLIC</code>, <code>F_PRIVATE</code>, + * <code>F_PROTECTED</code>, <code>F_ABSTRACT</code>, + * <code>F_FINAL</code> or <code>F_STATIC</code> or a valid + * combination. + * @param canBeModified + * if <code>true</code> the modifier fields are editable; + * otherwise they are read-only + * @see Flags + */ + public void setModifiers(int modifiers, boolean canBeModified) { + if (Flags.isPublic(modifiers)) { + fAccMdfButtons.setSelection(PUBLIC_INDEX, true); + } else if (Flags.isPrivate(modifiers)) { + fAccMdfButtons.setSelection(PRIVATE_INDEX, true); + } else if (Flags.isProtected(modifiers)) { + fAccMdfButtons.setSelection(PROTECTED_INDEX, true); + } else { + fAccMdfButtons.setSelection(DEFAULT_INDEX, true); + } + if (Flags.isAbstract(modifiers)) { + fOtherMdfButtons.setSelection(ABSTRACT_INDEX, true); + } + if (Flags.isFinal(modifiers)) { + fOtherMdfButtons.setSelection(FINAL_INDEX, true); + } + if (Flags.isStatic(modifiers)) { + fOtherMdfButtons.setSelection(STATIC_INDEX, true); + } + + fAccMdfButtons.setEnabled(canBeModified); + fOtherMdfButtons.setEnabled(canBeModified); + } + + /** + * Returns the content of the superclass input field. + * + * @return the superclass name + */ + public String getSuperClass() { + return fSuperClassDialogField.getText(); + } + + /** + * Sets the super class name. + * + * @param name + * the new superclass name + * @param canBeModified + * if <code>true</code> the superclass name field is editable; + * otherwise it is read-only. + */ + public void setSuperClass(String name, boolean canBeModified) { + fSuperClassDialogField.setText(name); + fSuperClassDialogField.setEnabled(canBeModified); + } + + /** + * Returns the chosen super interfaces. + * + * @return a list of chosen super interfaces. The list's elements are of + * type <code>String</code> + */ + public List getSuperInterfaces() { + List interfaces = fSuperInterfacesDialogField.getElements(); + ArrayList result = new ArrayList(interfaces.size()); + for (Iterator iter = interfaces.iterator(); iter.hasNext();) { + InterfaceWrapper wrapper = (InterfaceWrapper) iter.next(); + result.add(wrapper.interfaceName); + } + return result; + } + + /** + * Sets the super interfaces. + * + * @param interfacesNames + * a list of super interface. The method requires that the list's + * elements are of type <code>String</code> + * @param canBeModified + * if <code>true</code> the super interface field is editable; + * otherwise it is read-only. + */ + public void setSuperInterfaces(List interfacesNames, boolean canBeModified) { + ArrayList interfaces = new ArrayList(interfacesNames.size()); + for (Iterator iter = interfacesNames.iterator(); iter.hasNext();) { + interfaces.add(new InterfaceWrapper((String) iter.next())); + } + fSuperInterfacesDialogField.setElements(interfaces); + fSuperInterfacesDialogField.setEnabled(canBeModified); + } + + /** + * Adds a super interface to the end of the list and selects it if it is not + * in the list yet. + * + * @param superInterface + * the fully qualified type name of the interface. + * @return returns <code>true</code>if the interfaces has been added, + * <code>false</code> if the interface already is in the list. + * @since 3.2 + */ + public boolean addSuperInterface(String superInterface) { + return fSuperInterfacesDialogField.addElement(new InterfaceWrapper( + superInterface)); + } + + /** + * Sets 'Add comment' checkbox. The value set will only be used when + * creating source when the comment control is enabled (see + * {@link #enableCommentControl(boolean)} + * + * @param doAddComments + * if <code>true</code>, comments are added. + * @param canBeModified + * if <code>true</code> check box is editable; otherwise it is + * read-only. + * @since 3.1 + */ + // public void setAddComments(boolean doAddComments, boolean canBeModified) { + // //fAddCommentButton.setSelection(doAddComments); + // //fAddCommentButton.setEnabled(canBeModified); + // } + /** + * Sets to use the 'Add comment' checkbox value. Clients that use the 'Add + * comment' checkbox additionally have to enable the control. This has been + * added for backwards compatibility. + * + * @param useAddCommentValue + * if <code>true</code>, + * @since 3.1 + */ + // public void enableCommentControl(boolean useAddCommentValue) { + // fUseAddCommentButtonValue= useAddCommentValue; + // } + + /** + * Returns if comments are added. This method can be overridden by clients. + * The selection of the comment control is taken if enabled (see + * {@link #enableCommentControl(boolean)}, otherwise the settings as + * specified in the preferences is used. + * + * @return Returns <code>true</code> if comments can be added + * @since 3.1 + */ + // public boolean isAddComments() { + // if (fUseAddCommentButtonValue) { + // return fAddCommentButton.isSelected(); + // } + // return StubUtility.doAddComments(getJavaProject()); + // } + // + /** + * Returns the resource handle that corresponds to the compilation unit to + * was or will be created or modified. + * + * @return A resource or null if the page contains illegal values. + * @since 3.0 + */ + public IResource getModifiedResource() { + IType enclosing = getEnclosingType(); + if (enclosing != null) { + return enclosing.getResource(); + } + IPackageFragment pack = getPackageFragment(); + if (pack != null) { + String cuName = getCompilationUnitName(getTypeNameWithoutParameters()); + return pack.getJavaScriptUnit(cuName).getResource(); + } + return null; + } + + // ----------- validation ---------- + + /* + * @see org.eclipse.wst.jsdt.ui.wizards.NewContainerWizardPage#containerChanged() + */ + protected IStatus containerChanged() { + return null; + // IStatus status= super.containerChanged(); + // // IPackageFragmentRoot root= getPackageFragmentRoot(); + // if ((fTypeKind == ANNOTATION_TYPE || fTypeKind == ENUM_TYPE) && + // !status.matches(IStatus.ERROR)) { + // if (root != null && !JavaModelUtil.is50OrHigher(root.getJavaProject())) { + // // error as createType will fail otherwise (bug 96928) + // return new StatusInfo(IStatus.ERROR, + // Messages.format(NewWizardMessages.NewTypeWizardPage_warning_NotJDKCompliant, + // root.getJavaProject().getElementName())); + // } + // if (fTypeKind == ENUM_TYPE) { + // try { + // // if findType(...) == null then Enum is unavailable + // if (findType(root.getJavaProject(), "java.lang.Enum") == null) //$NON-NLS-1$ + // return new StatusInfo(IStatus.WARNING, + // NewWizardMessages.NewTypeWizardPage_warning_EnumClassNotFound); + // } catch (JavaScriptModelException e) { + // JavaScriptPlugin.log(e); + // } + // } + // } + // + // fCurrPackageCompletionProcessor.setPackageFragmentRoot(root); + // if (root != null) { + // fEnclosingTypeCompletionProcessor.setPackageFragment(root.getPackageFragment("")); + // //$NON-NLS-1$ + // } + // return status; + } + + /** + * A hook method that gets called when the package field has changed. The + * method validates the package name and returns the status of the + * validation. The validation also updates the package fragment model. + * <p> + * Subclasses may extend this method to perform their own validation. + * </p> + * + * @return the status of the validation + */ + protected IStatus packageChanged() { + // StatusInfo status= new StatusInfo(); + // IPackageFragmentRoot root= getPackageFragmentRoot(); + // fPackageDialogField.enableButton(root != null); + // + // IJavaScriptProject project= root != null ? root.getJavaProject() : null; + // + // String packName= getPackageText(); + // if (packName.length() > 0) { + // IStatus val= validatePackageName(packName, project); + // if (val.getSeverity() == IStatus.ERROR) { + // status.setError(Messages.format(NewWizardMessages.NewTypeWizardPage_error_InvalidPackageName, + // val.getMessage())); + // return status; + // } else if (val.getSeverity() == IStatus.WARNING) { + // status.setWarning(Messages.format(NewWizardMessages.NewTypeWizardPage_warning_DiscouragedPackageName, + // val.getMessage())); + // // continue + // } + // } else { + // status.setWarning(NewWizardMessages.NewTypeWizardPage_warning_DefaultPackageDiscouraged); + // } + // + // if (project != null) { + // if (project.exists() && packName.length() > 0) { + // try { + // IPath rootPath= root.getPath(); + // IPath outputPath= project.getOutputLocation(); + // if (rootPath.isPrefixOf(outputPath) && !rootPath.equals(outputPath)) { + // // if the bin folder is inside of our root, don't allow to name a package + // // like the bin folder + // IPath packagePath= rootPath.append(packName.replace('.', '/')); + // if (outputPath.isPrefixOf(packagePath)) { + // status.setError(NewWizardMessages.NewTypeWizardPage_error_ClashOutputLocation); + // return status; + // } + // } + // } catch (JavaScriptModelException e) { + // JavaScriptPlugin.log(e); + // // let pass + // } + // } + // + // fCurrPackage= root.getPackageFragment(packName); + // } else { + // status.setError(""); //$NON-NLS-1$ + // } + // return status; + return null; + } + + /* + * Updates the 'default' label next to the package field. + */ + private void updatePackageStatusLabel() { + // String packName= getPackageText(); + // + // if (packName.length() == 0) { + // fPackageDialogField.setStatus(NewWizardMessages.NewTypeWizardPage_default); + // } else { + // fPackageDialogField.setStatus(""); //$NON-NLS-1$ + // } + } + + /* + * Updates the enable state of buttons related to the enclosing type + * selection checkbox. + */ + private void updateEnableState() { + boolean enclosing = isEnclosingTypeSelected(); + fFolderName.setEnabled(!enclosing); + fExistingFileName.setEnabled(enclosing); + fOtherMdfButtons.enableSelectionButton(ABSTRACT_INDEX, enclosing); + fOtherMdfButtons.enableSelectionButton(ENUM_ANNOT_STATIC_INDEX, + enclosing); + + // if (fTypeKind == ENUM_TYPE || fTypeKind == ANNOTATION_TYPE) { + // fOtherMdfButtons.enableSelectionButton(ABSTRACT_INDEX, enclosing); + // fOtherMdfButtons.enableSelectionButton(ENUM_ANNOT_STATIC_INDEX, enclosing); + // } + } + + /** + * Hook method that gets called when the enclosing type name has changed. + * The method validates the enclosing type and returns the status of the + * validation. It also updates the enclosing type model. + * <p> + * Subclasses may extend this method to perform their own validation. + * </p> + * + * @return the status of the validation + */ + protected IStatus enclosingTypeChanged() { + return null; + // StatusInfo status= new StatusInfo(); + // fCurrEnclosingType= null; + // + // IPackageFragmentRoot root= getPackageFragmentRoot(); + // + // fEnclosingTypeDialogField.enableButton(root != null); + // if (root == null) { + // status.setError(""); //$NON-NLS-1$ + // return status; + // } + // + // String enclName= getEnclosingTypeText(); + // if (enclName.length() == 0) { + // status.setError(NewWizardMessages.NewTypeWizardPage_error_EnclosingTypeEnterName); + // return status; + // } + // try { + // IType type= findType(root.getJavaProject(), enclName); + // if (type == null) { + // status.setError(NewWizardMessages.NewTypeWizardPage_error_EnclosingTypeNotExists); + // return status; + // } + // + // if (type.getCompilationUnit() == null) { + // status.setError(NewWizardMessages.NewTypeWizardPage_error_EnclosingNotInCU); + // return status; + // } + // if (!JavaModelUtil.isEditable(type.getCompilationUnit())) { + // status.setError(NewWizardMessages.NewTypeWizardPage_error_EnclosingNotEditable); + // return status; + // } + // + // fCurrEnclosingType= type; + // IPackageFragmentRoot enclosingRoot= + // JavaModelUtil.getPackageFragmentRoot(type); + // if (!enclosingRoot.equals(root)) { + // status.setWarning(NewWizardMessages.NewTypeWizardPage_warning_EnclosingNotInSourceFolder); + // } + // return status; + // } catch (JavaScriptModelException e) { + // status.setError(NewWizardMessages.NewTypeWizardPage_error_EnclosingTypeNotExists); + // JavaScriptPlugin.log(e); + // return status; + // } + } + + private String getTypeNameWithoutParameters() { + String typeNameWithParameters = getTypeName(); + int angleBracketOffset = typeNameWithParameters.indexOf('<'); + if (angleBracketOffset == -1) { + return typeNameWithParameters; + } else { + return typeNameWithParameters.substring(0, angleBracketOffset); + } + } + + /** + * Hook method that is called when evaluating the name of the compilation + * unit to create. By default, a file extension <code>java</code> is added + * to the given type name, but implementors can override this behavior. + * + * @param typeName + * the name of the type to create the compilation unit for. + * @return the name of the compilation unit to be created for the given name + * + * @since 3.2 + */ + protected String getCompilationUnitName(String typeName) { + return typeName + JavaModelUtil.DEFAULT_CU_SUFFIX; + } + + /** + * Hook method that gets called when the type name has changed. The method + * validates the type name and returns the status of the validation. + * <p> + * Subclasses may extend this method to perform their own validation. + * </p> + * + * @return the status of the validation + */ + protected IStatus typeNameChanged() { + StatusInfo status = new StatusInfo(); + fCurrType = null; + String typeNameWithParameters = getTypeName(); + // must not be empty + if (typeNameWithParameters.length() == 0) { + status + .setError(NewWizardMessages.NewTypeWizardPage_error_EnterTypeName); + return status; + } + + String typeName = getTypeNameWithoutParameters(); + if (typeName.indexOf('.') != -1) { + status + .setError(NewWizardMessages.NewTypeWizardPage_error_QualifiedName); + return status; + } + + IJavaScriptProject project = getJavaProject(); + IStatus val = validateJavaTypeName(typeName, project); + if (val.getSeverity() == IStatus.ERROR) { + status.setError(Messages.format( + NewWizardMessages.NewTypeWizardPage_error_InvalidTypeName, + val.getMessage())); + return status; + } else if (val.getSeverity() == IStatus.WARNING) { + status + .setWarning(Messages + .format( + NewWizardMessages.NewTypeWizardPage_warning_TypeNameDiscouraged, + val.getMessage())); + // continue checking + } + + // must not exist + if (!isEnclosingTypeSelected()) { + IPackageFragment pack = getPackageFragment(); + if (pack != null) { + IJavaScriptUnit cu = pack + .getJavaScriptUnit(getCompilationUnitName(typeName)); + fCurrType = cu.getType(typeName); + IResource resource = cu.getResource(); + + if (resource.exists()) { + status + .setError(NewWizardMessages.NewTypeWizardPage_error_TypeNameExists); + return status; + } + URI location = resource.getLocationURI(); + if (location != null) { + try { + IFileStore store = EFS.getStore(location); + if (store.fetchInfo().exists()) { + status + .setError(NewWizardMessages.NewTypeWizardPage_error_TypeNameExistsDifferentCase); + return status; + } + } catch (CoreException e) { + status + .setError(Messages + .format( + NewWizardMessages.NewTypeWizardPage_error_uri_location_unkown, + Resources + .getLocationString(resource))); + } + } + } + } else { + IType type = getEnclosingType(); + if (type != null) { + fCurrType = type.getType(typeName); + if (fCurrType.exists()) { + status + .setError(NewWizardMessages.NewTypeWizardPage_error_TypeNameExists); + return status; + } + } + } + + if (!typeNameWithParameters.equals(typeName) && project != null) { + if (!JavaModelUtil.is50OrHigher(project)) { + status + .setError(NewWizardMessages.NewTypeWizardPage_error_TypeParameters); + return status; + } + String typeDeclaration = "class " + typeNameWithParameters + " {}"; //$NON-NLS-1$//$NON-NLS-2$ + ASTParser parser = ASTParser.newParser(AST.JLS3); + parser.setSource(typeDeclaration.toCharArray()); + parser.setProject(project); + JavaScriptUnit compilationUnit = (JavaScriptUnit) parser + .createAST(null); + IProblem[] problems = compilationUnit.getProblems(); + if (problems.length > 0) { + status + .setError(Messages + .format( + NewWizardMessages.NewTypeWizardPage_error_InvalidTypeName, + problems[0].getMessage())); + return status; + } + } + return status; + } + + /** + * Hook method that gets called when the superclass name has changed. The + * method validates the superclass name and returns the status of the + * validation. + * <p> + * Subclasses may extend this method to perform their own validation. + * </p> + * + * @return the status of the validation + */ + protected IStatus superClassChanged() { + return null; + // StatusInfo status= new StatusInfo(); + // IPackageFragmentRoot root= getPackageFragmentRoot(); + // fSuperClassDialogField.enableButton(root != null); + // + // fSuperClassStubTypeContext= null; + // + // String sclassName= getSuperClass(); + // if (sclassName.length() == 0) { + // // accept the empty field (stands for java.lang.Object) + // return status; + // } + // + // if (root != null) { + // Type type= TypeContextChecker.parseSuperClass(sclassName); + // if (type == null) { + // status.setError(NewWizardMessages.NewTypeWizardPage_error_InvalidSuperClassName); + // return status; + // } + // if (type instanceof ParameterizedType && ! + // JavaModelUtil.is50OrHigher(root.getJavaProject())) { + // status.setError(NewWizardMessages.NewTypeWizardPage_error_SuperClassNotParameterized); + // return status; + // } + // } else { + // status.setError(""); //$NON-NLS-1$ + // } + // return status; + } + + private StubTypeContext getSuperClassStubTypeContext() { + if (fSuperClassStubTypeContext == null) { + String typeName; + if (fCurrType != null) { + typeName = getTypeName(); + } else { + typeName = JavaTypeCompletionProcessor.DUMMY_CLASS_NAME; + } + fSuperClassStubTypeContext = TypeContextChecker + .createSuperClassStubTypeContext(typeName, + getEnclosingType(), getPackageFragment()); + } + return fSuperClassStubTypeContext; + } + + /** + * Hook method that gets called when the list of super interface has + * changed. The method validates the super interfaces and returns the status + * of the validation. + * <p> + * Subclasses may extend this method to perform their own validation. + * </p> + * + * @return the status of the validation + */ + protected IStatus superInterfacesChanged() { + return null; + // StatusInfo status= new StatusInfo(); + // + // IPackageFragmentRoot root= getPackageFragmentRoot(); + // fSuperInterfacesDialogField.enableButton(0, root != null); + // + // if (root != null) { + // List elements= fSuperInterfacesDialogField.getElements(); + // int nElements= elements.size(); + // for (int i= 0; i < nElements; i++) { + // String intfname= ((InterfaceWrapper) elements.get(i)).interfaceName; + // Type type= TypeContextChecker.parseSuperInterface(intfname); + // if (type == null) { + // status.setError(Messages.format(NewWizardMessages.NewTypeWizardPage_error_InvalidSuperInterfaceName, + // intfname)); + // return status; + // } + // if (type instanceof ParameterizedType && ! + // JavaModelUtil.is50OrHigher(root.getJavaProject())) { + // status.setError(Messages.format(NewWizardMessages.NewTypeWizardPage_error_SuperInterfaceNotParameterized, + // intfname)); + // return status; + // } + // } + // } + // return status; + } + + private StubTypeContext getSuperInterfacesStubTypeContext() { + if (fSuperInterfaceStubTypeContext == null) { + String typeName; + if (fCurrType != null) { + typeName = getTypeName(); + } else { + typeName = JavaTypeCompletionProcessor.DUMMY_CLASS_NAME; + } + fSuperInterfaceStubTypeContext = TypeContextChecker + .createSuperInterfaceStubTypeContext(typeName, + getEnclosingType(), getPackageFragment()); + } + return fSuperInterfaceStubTypeContext; + } + + /** + * Hook method that gets called when the modifiers have changed. The method + * validates the modifiers and returns the status of the validation. + * <p> + * Subclasses may extend this method to perform their own validation. + * </p> + * + * @return the status of the validation + */ + protected IStatus modifiersChanged() { + StatusInfo status = new StatusInfo(); + int modifiers = getModifiers(); + if (Flags.isFinal(modifiers) && Flags.isAbstract(modifiers)) { + status + .setError(NewWizardMessages.NewTypeWizardPage_error_ModifiersFinalAndAbstract); + } + return status; + } + + // selection dialogs + + protected IResource chooseFolder() { + IProject fCurrProject = getJavaProject() != null ? getJavaProject() + .getProject() : null; + if (fCurrProject == null) + return null; + + // IWorkspaceRoot root= fCurrProject.getWorkspace().getRoot(); + final Class[] acceptedClasses = new Class[] { IFolder.class }; + + ILabelProvider lp = new WorkbenchLabelProvider(); + ITreeContentProvider cp = new WorkbenchContentProvider(); + + IResource initSelection = fCurrProject; + + Object[] rejects = new Object[] { fCurrProject.findMember(".settings") }; + + ViewerFilter filter = new TypedViewerFilter(acceptedClasses, rejects); + + FolderSelectionDialog dialog = new FolderSelectionDialog(getShell(), + lp, cp); + + dialog.setTitle("Folder Selection"); + dialog + .setMessage(NewWizardMessages.NewTypeWizardPage_ChoosePackageDialog_description); + // dialog.setEmptyListMessage(NewWizardMessages.NewTypeWizardPage_ChoosePackageDialog_empty); + // dialog.setElements( new Object[] {head}); + + dialog.addFilter(filter); + dialog.setHelpAvailable(false); + dialog.setAllowMultiple(false); + dialog.setInput(initSelection); + if (dialog.open() == Window.OK) { + return (IResource) dialog.getFirstResult(); + } + return null; + } + + /** + * Opens a selection dialog that allows to select a package. + * + * @return returns the selected package or <code>null</code> if the dialog + * has been canceled. The caller typically sets the result to the + * package input field. + * <p> + * Clients can override this method if they want to offer a + * different dialog. + * </p> + * + * @since 3.2 + */ + // protected IPackageFragment choosePackage2() { + // IJavaScriptProject javaProject = getJavaProject(); + // IPackageFragmentRoot froot= null;; + // IJavaScriptElement[] packages= null; + // try { + // if (froot != null && froot.exists()) { + // packages= froot.getChildren(); + // } + // } catch (JavaScriptModelException e) { + // JavaScriptPlugin.log(e); + // } + // if (packages == null) { + // packages= new IJavaScriptElement[0]; + // } + // + // ElementListSelectionDialog dialog= new ElementListSelectionDialog(getShell(), + // new JavaScriptElementLabelProvider(JavaScriptElementLabelProvider.SHOW_DEFAULT)); + // dialog.setIgnoreCase(false); + // dialog.setTitle(NewWizardMessages.NewTypeWizardPage_ChoosePackageDialog_title); + // dialog.setMessage(NewWizardMessages.NewTypeWizardPage_ChoosePackageDialog_description); + // dialog.setEmptyListMessage(NewWizardMessages.NewTypeWizardPage_ChoosePackageDialog_empty); + // dialog.setElements(packages); + // dialog.setHelpAvailable(false); + // + // IPackageFragment pack= getPackageFragment(); + // if (pack != null) { + // dialog.setInitialSelections(new Object[] { pack }); + // } + // + // if (dialog.open() == Window.OK) { + // return (IPackageFragment) dialog.getFirstResult(); + // } + // return null; + // } + /** + * Opens a selection dialog that allows to select an enclosing type. + * + * @return returns the selected type or <code>null</code> if the dialog + * has been canceled. The caller typically sets the result to the + * enclosing type input field. + * <p> + * Clients can override this method if they want to offer a + * different dialog. + * </p> + * + * @since 3.2 + */ + protected IResource chooseExistingFile() { + IProject fCurrProject = getJavaProject() != null ? getJavaProject() + .getProject() : null; + if (fCurrProject == null) + return null; + + // IWorkspaceRoot root= fCurrProject.getWorkspace().getRoot(); + final Class[] acceptedClasses = new Class[] { IFile.class, + IFolder.class }; + + ILabelProvider lp = new WorkbenchLabelProvider(); + ITreeContentProvider cp = new WorkbenchContentProvider(); + + IResource initSelection = fCurrProject; + + Object[] rejects = new Object[] { fCurrProject.findMember(".settings") }; + + ViewerFilter filter = new TypedViewerFilter(acceptedClasses, rejects); + + FolderSelectionDialog dialog = new FolderSelectionDialog(getShell(), + lp, cp); + + final String[] validFileExtensions = { "js"/* ,"html","htm" */}; + dialog.setValidator(new ISelectionStatusValidator() { + + public IStatus validate(Object[] selection) { + if (selection == null || selection.length > 1 + || selection.length == 0) + return new Status(IStatus.ERROR, "org.ibm.jsdt.dojo", + "You must select a valid JavaScript source file."); + + if (selection[0] instanceof IFile) { + IFile theFile = (IFile) selection[0]; + String fileExtension = theFile.getFileExtension(); + for (int i = 0; i < validFileExtensions.length; i++) { + if (fileExtension != null + && fileExtension + .equalsIgnoreCase(validFileExtensions[i])) { + return new Status(IStatus.OK, "org.ibm.jsdt.dojo", + "Great Job!"); + } + } + + } + + return new Status(IStatus.ERROR, "org.ibm.jsdt.dojo", + "You must select a valid JavaScript source file."); + } + }); + + dialog.setTitle("Existing File Selection"); + dialog.setMessage("Choose a file"); + // dialog.setEmptyListMessage(NewWizardMessages.NewTypeWizardPage_ChoosePackageDialog_empty); + // dialog.setElements( new Object[] {head}); + + dialog.addFilter(filter); + dialog.setHelpAvailable(false); + dialog.setAllowMultiple(false); + dialog.setInput(initSelection); + if (dialog.open() == Window.OK) { + return (IResource) dialog.getFirstResult(); + } + return null; + } + + /** + * Opens a selection dialog that allows to select a super class. + * + * @return returns the selected type or <code>null</code> if the dialog + * has been canceled. The caller typically sets the result to the + * super class input field. + * <p> + * Clients can override this method if they want to offer a + * different dialog. + * </p> + * + * @since 3.2 + */ + protected IType chooseSuperClass() { + IJavaScriptProject project = getJavaProject(); + if (project == null) { + return null; + } + + IJavaScriptElement[] elements = new IJavaScriptElement[] { project }; + IJavaScriptSearchScope scope = SearchEngine.createJavaSearchScope(elements); + + FilteredTypesSelectionDialog dialog = new FilteredTypesSelectionDialog( + getShell(), false, getWizard().getContainer(), scope, + IJavaScriptSearchConstants.CLASS); + dialog + .setTitle(NewWizardMessages.NewTypeWizardPage_SuperClassDialog_title); + dialog + .setMessage(NewWizardMessages.NewTypeWizardPage_SuperClassDialog_message); + dialog.setInitialPattern(getSuperClass()); + + if (dialog.open() == Window.OK) { + return (IType) dialog.getFirstResult(); + } + return null; + } + + /** + * Opens a selection dialog that allows to select the super interfaces. The + * selected interfaces are directly added to the wizard page using + * {@link #addSuperInterface(String)}. + * + * <p> + * Clients can override this method if they want to offer a different + * dialog. + * </p> + * + * @since 3.2 + */ + protected void chooseSuperInterfaces() { + IJavaScriptProject project = getJavaProject(); + if (project == null) { + return; + } + + SuperInterfaceSelectionDialog dialog = new SuperInterfaceSelectionDialog( + getShell(), getWizard().getContainer(), this, project); + dialog.setTitle(getInterfaceDialogTitle()); + dialog.setMessage("&Choose JavaScript Types"); + dialog.open(); + } + + private String getInterfaceDialogTitle() { + if (fTypeKind == INTERFACE_TYPE) + return NewWizardMessages.NewTypeWizardPage_InterfacesDialog_interface_title; + return "JavaScript Type Selection"; + } + + // ---- creation ---------------- + + /** + * Creates the new type using the entered field values. + * + * @param monitor + * a progress monitor to report progress. + * @throws CoreException + * Thrown when the creation failed. + * @throws InterruptedException + * Thrown when the operation was canceled. + */ + public void createType(IProgressMonitor monitor) throws CoreException, + InterruptedException { + // if (monitor == null) { + // monitor= new NullProgressMonitor(); + // } + // + // monitor.beginTask("Create Dojo Class...", 8); + // + // String newFileName; + // String existingFileName; + // String newPath; + // String className; + // String[] extendedClasses; + + // IPackageFragmentRoot root= getPackageFragmentRoot(); + // IPackageFragment pack= getPackageFragment(); + // if (pack == null) { + // pack= root.getPackageFragment(""); //$NON-NLS-1$ + // } + // + // if (!pack.exists()) { + // String packName= pack.getElementName(); + // pack= root.createPackageFragment(packName, true, new + // SubProgressMonitor(monitor, 1)); + // } else { + // monitor.worked(1); + // } + // + // boolean needsSave; + // IJavaScriptUnit connectedCU= null; + // + // try { + // String typeName= getTypeNameWithoutParameters(); + // + // boolean isInnerClass= isEnclosingTypeSelected(); + // + // IType createdType; + // ImportsManager imports; + // int indent= 0; + // + // Set /* String (import names) */ existingImports; + // + // String lineDelimiter= null; + // if (!isInnerClass) { + // lineDelimiter= StubUtility.getLineDelimiterUsed(pack.getJavaProject()); + // + // String cuName= getCompilationUnitName(typeName); + // IJavaScriptUnit parentCU= pack.createCompilationUnit(cuName, "", false, new + // SubProgressMonitor(monitor, 2)); //$NON-NLS-1$ + // // create a working copy with a new owner + // + // needsSave= true; + // parentCU.becomeWorkingCopy(new SubProgressMonitor(monitor, 1)); // cu is now + // a (primary) working copy + // connectedCU= parentCU; + // + // IBuffer buffer= parentCU.getBuffer(); + // + // String simpleTypeStub= constructSimpleTypeStub(); + // String cuContent= constructCUContent(parentCU, simpleTypeStub, + // lineDelimiter); + // buffer.setContents(cuContent); + // + // JavaScriptUnit astRoot= createASTForImports(parentCU); + // existingImports= getExistingImports(astRoot); + // + // imports= new ImportsManager(astRoot); + // // add an import that will be removed again. Having this import solves 14661 + // imports.addImport(JavaModelUtil.concatenateName(pack.getElementName(), + // typeName)); + // + // String typeContent= constructTypeStub(parentCU, imports, lineDelimiter); + // + // int index= cuContent.lastIndexOf(simpleTypeStub); + // if (index == -1) { + // AbstractTypeDeclaration typeNode= (AbstractTypeDeclaration) + // astRoot.types().get(0); + // int start= ((ASTNode) typeNode.modifiers().get(0)).getStartPosition(); + // int end= typeNode.getStartPosition() + typeNode.getLength(); + // buffer.replace(start, end - start, typeContent); + // } else { + // buffer.replace(index, simpleTypeStub.length(), typeContent); + // } + // + // createdType= parentCU.getType(typeName); + // } else { + // IType enclosingType= getEnclosingType(); + // + // IJavaScriptUnit parentCU= enclosingType.getCompilationUnit(); + // + // needsSave= !parentCU.isWorkingCopy(); + // parentCU.becomeWorkingCopy(new SubProgressMonitor(monitor, 1)); // cu is now + // for sure (primary) a working copy + // connectedCU= parentCU; + // + // JavaScriptUnit astRoot= createASTForImports(parentCU); + // imports= new ImportsManager(astRoot); + // existingImports= getExistingImports(astRoot); + // + // + // // add imports that will be removed again. Having the imports solves 14661 + // IType[] topLevelTypes= parentCU.getTypes(); + // for (int i= 0; i < topLevelTypes.length; i++) { + // imports.addImport(topLevelTypes[i].getFullyQualifiedName('.')); + // } + // + // lineDelimiter= StubUtility.getLineDelimiterUsed(enclosingType); + // StringBuffer content= new StringBuffer(); + // + // String comment= getTypeComment(parentCU, lineDelimiter); + // if (comment != null) { + // content.append(comment); + // content.append(lineDelimiter); + // } + // + // content.append(constructTypeStub(parentCU, imports, lineDelimiter)); + // IJavaScriptElement sibling= null; + // if (enclosingType.isEnum()) { + // IField[] fields = enclosingType.getFields(); + // if (fields.length > 0) { + // for (int i = 0, max = fields.length; i < max; i++) { + // if (!fields[i].isEnumConstant()) { + // sibling = fields[i]; + // break; + // } + // } + // } + // } else { + // IJavaScriptElement[] elems= enclosingType.getChildren(); + // sibling = elems.length > 0 ? elems[0] : null; + // } + // + // createdType= enclosingType.createType(content.toString(), sibling, false, new + // SubProgressMonitor(monitor, 2)); + // + // indent= StubUtility.getIndentUsed(enclosingType) + 1; + // } + // if (monitor.isCanceled()) { + // throw new InterruptedException(); + // } + // + // // add imports for superclass/interfaces, so types can be resolved correctly + // + // IJavaScriptUnit cu= createdType.getCompilationUnit(); + // + // imports.create(false, new SubProgressMonitor(monitor, 1)); + // + // JavaModelUtil.reconcile(cu); + // + // if (monitor.isCanceled()) { + // throw new InterruptedException(); + // } + // + // // set up again + // JavaScriptUnit astRoot= createASTForImports(imports.getCompilationUnit()); + // imports= new ImportsManager(astRoot); + // + // createTypeMembers(createdType, imports, new SubProgressMonitor(monitor, 1)); + // + // // add imports + // imports.create(false, new SubProgressMonitor(monitor, 1)); + // + // removeUnusedImports(cu, existingImports, false); + // + // JavaModelUtil.reconcile(cu); + // + // ISourceRange range= createdType.getSourceRange(); + // + // IBuffer buf= cu.getBuffer(); + // String originalContent= buf.getText(range.getOffset(), range.getLength()); + // + // String formattedContent= + // CodeFormatterUtil.format(CodeFormatter.K_CLASS_BODY_DECLARATIONS, + // originalContent, indent, null, lineDelimiter, pack.getJavaProject()); + // formattedContent= Strings.trimLeadingTabsAndSpaces(formattedContent); + // buf.replace(range.getOffset(), range.getLength(), formattedContent); + // if (!isInnerClass) { + // String fileComment= getFileComment(cu); + // if (fileComment != null && fileComment.length() > 0) { + // buf.replace(0, 0, fileComment + lineDelimiter); + // } + // } + // fCreatedType= createdType; + // + // if (needsSave) { + // cu.commitWorkingCopy(true, new SubProgressMonitor(monitor, 1)); + // } else { + // monitor.worked(1); + // } + // + // } finally { + // if (connectedCU != null) { + // connectedCU.discardWorkingCopy(); + // } + // monitor.done(); + // } + } + + /** + * Uses the New Java file template from the code template page to generate a + * compilation unit with the given type content. + * + * @param cu + * The new created compilation unit + * @param typeContent + * The content of the type, including signature and type body. + * @param lineDelimiter + * The line delimiter to be used. + * @return String Returns the result of evaluating the new file template + * with the given type content. + * @throws CoreException + * @since 2.1 + */ + protected String constructCUContent(IJavaScriptUnit cu, + String typeContent, String lineDelimiter) throws CoreException { + // String fileComment= getFileComment(cu, lineDelimiter); + // String typeComment= getTypeComment(cu, lineDelimiter); + IPackageFragment pack = (IPackageFragment) cu.getParent(); + String content = null;// CodeGeneration.getCompilationUnitContent(cu, + // fileComment, typeComment, typeContent, + // lineDelimiter); + if (content != null) { + ASTParser parser = ASTParser.newParser(AST.JLS3); + parser.setProject(cu.getJavaScriptProject()); + parser.setSource(content.toCharArray()); + JavaScriptUnit unit = (JavaScriptUnit) parser.createAST(null); + if ((pack.isDefaultPackage() || unit.getPackage() != null) + && !unit.types().isEmpty()) { + return content; + } + } + StringBuffer buf = new StringBuffer(); + if (!pack.isDefaultPackage()) { + buf.append("package ").append(pack.getElementName()).append(';'); //$NON-NLS-1$ + } + buf.append(lineDelimiter).append(lineDelimiter); + // if (typeComment != null) { + // buf.append(typeComment).append(lineDelimiter); + // } + buf.append(typeContent); + return buf.toString(); + } + + /** + * Returns the created type or <code>null</code> is the type has not been + * created yet. The method only returns a valid type after + * <code>createType</code> has been called. + * + * @return the created type + * @see #createType(IProgressMonitor) + */ + public IType getCreatedType() { + return fCreatedType; + } + + // ---- construct CU body---------------- + + private void writeSuperClass(StringBuffer buf, ImportsManager imports) { + String superclass = getSuperClass(); + if (fTypeKind == CLASS_TYPE && superclass.length() > 0 + && !"java.lang.Object".equals(superclass)) { //$NON-NLS-1$ + buf.append(" extends "); //$NON-NLS-1$ + + ITypeBinding binding = null; + if (fCurrType != null) { + binding = TypeContextChecker.resolveSuperClass(superclass, + fCurrType, getSuperClassStubTypeContext()); + } + if (binding != null) { + buf.append(imports.addImport(binding)); + } else { + buf.append(imports.addImport(superclass)); + } + } + } + + private void writeSuperInterfaces(StringBuffer buf, ImportsManager imports) { + List interfaces = getSuperInterfaces(); + int last = interfaces.size() - 1; + if (last >= 0) { + if (fTypeKind != INTERFACE_TYPE) { + buf.append(" implements "); //$NON-NLS-1$ + } else { + buf.append(" extends "); //$NON-NLS-1$ + } + String[] intfs = (String[]) interfaces + .toArray(new String[interfaces.size()]); + ITypeBinding[] bindings; + if (fCurrType != null) { + bindings = TypeContextChecker.resolveSuperInterfaces(intfs, + fCurrType, getSuperInterfacesStubTypeContext()); + } else { + bindings = new ITypeBinding[intfs.length]; + } + for (int i = 0; i <= last; i++) { + ITypeBinding binding = bindings[i]; + if (binding != null) { + buf.append(imports.addImport(binding)); + } else { + buf.append(imports.addImport(intfs[i])); + } + if (i < last) { + buf.append(','); + } + } + } + } + + /** + * @param parentCU + * the current compilation unit + * @return returns the file template or <code>null</code> + * @deprecated Instead of file templates, the new type code template + * specifies the stub for a compilation unit. + */ + protected String getFileComment(IJavaScriptUnit parentCU) { + return null; + } + + /** + * @param name + * the name of the template + * @param parentCU + * the current compilation unit + * @return returns the template or <code>null</code> + * @deprecated Use getTemplate(String,IJavaScriptUnit,int) + */ + protected String getTemplate(String name, IJavaScriptUnit parentCU) { + return getTemplate(name, parentCU, 0); + } + + /** + * Returns the string resulting from evaluation the given template in the + * context of the given compilation unit. This accesses the normal template + * page, not the code templates. To use code templates use + * <code>constructCUContent</code> to construct a compilation unit stub or + * getTypeComment for the comment of the type. + * + * @param name + * the template to be evaluated + * @param parentCU + * the templates evaluation context + * @param pos + * a source offset into the parent compilation unit. The template + * is evaluated at the given source offset + * @return return the template with the given name or <code>null</code> if + * the template could not be found. + */ + protected String getTemplate(String name, IJavaScriptUnit parentCU, int pos) { + try { + Template template = JavaScriptPlugin.getDefault().getTemplateStore() + .findTemplate(name); + if (template != null) { + return JavaContext.evaluateTemplate(template, parentCU, pos); + } + } catch (CoreException e) { + JavaScriptPlugin.log(e); + } catch (BadLocationException e) { + JavaScriptPlugin.log(e); + } catch (TemplateException e) { + JavaScriptPlugin.log(e); + } + return null; + } + + /** + * Creates the bodies of all unimplemented methods and constructors and adds + * them to the type. Method is typically called by implementers of + * <code>NewTypeWizardPage</code> to add needed method and constructors. + * + * @param type + * the type for which the new methods and constructor are to be + * created + * @param doConstructors + * if <code>true</code> unimplemented constructors are created + * @param doUnimplementedMethods + * if <code>true</code> unimplemented methods are created + * @param imports + * an import manager to add all needed import statements + * @param monitor + * a progress monitor to report progress + * @return the created methods. + * @throws CoreException + * thrown when the creation fails. + */ + protected IFunction[] createInheritedMethods(IType type, + boolean doConstructors, boolean doUnimplementedMethods, + ImportsManager imports, IProgressMonitor monitor) + throws CoreException { + final IJavaScriptUnit cu = type.getJavaScriptUnit(); + JavaModelUtil.reconcile(cu); + IFunction[] typeMethods = type.getFunctions(); + Set handleIds = new HashSet(typeMethods.length); + for (int index = 0; index < typeMethods.length; index++) + handleIds.add(typeMethods[index].getHandleIdentifier()); + ArrayList newMethods = new ArrayList(); + JavaPreferencesSettings + .getCodeGenerationSettings(type.getJavaScriptProject()); + // settings.createComments= isAddComments(); + ASTParser parser = ASTParser.newParser(AST.JLS3); + parser.setResolveBindings(true); + parser.setSource(cu); + JavaScriptUnit unit = (JavaScriptUnit) parser + .createAST(new SubProgressMonitor(monitor, 1)); + final ITypeBinding binding = ASTNodes.getTypeBinding(unit, type); + if (binding != null) { + if (doUnimplementedMethods) { + AddUnimplementedMethodsOperation operation = new AddUnimplementedMethodsOperation( + unit, binding, null, -1, false, true, false); + // operation.setCreateComments(isAddComments()); + operation.run(monitor); + createImports(imports, operation.getCreatedImports()); + } + if (doConstructors) { + AddUnimplementedConstructorsOperation operation = new AddUnimplementedConstructorsOperation( + unit, binding, null, -1, false, true, false); + operation.setOmitSuper(true); + // operation.setCreateComments(isAddComments()); + operation.run(monitor); + createImports(imports, operation.getCreatedImports()); + } + } + JavaModelUtil.reconcile(cu); + typeMethods = type.getFunctions(); + for (int index = 0; index < typeMethods.length; index++) + if (!handleIds.contains(typeMethods[index].getHandleIdentifier())) + newMethods.add(typeMethods[index]); + IFunction[] methods = new IFunction[newMethods.size()]; + newMethods.toArray(methods); + return methods; + } + + private void createImports(ImportsManager imports, String[] createdImports) { + for (int index = 0; index < createdImports.length; index++) + imports.addImport(createdImports[index]); + } + + // ---- creation ---------------- + + /** + * Returns the runnable that creates the type using the current settings. + * The returned runnable must be executed in the UI thread. + * + * @return the runnable to create the new type + */ + public IRunnableWithProgress getRunnable() { + return new IRunnableWithProgress() { + public void run(IProgressMonitor monitor) + throws InvocationTargetException, InterruptedException { + try { + if (monitor == null) { + monitor = new NullProgressMonitor(); + } + createType(monitor); + } catch (CoreException e) { + throw new InvocationTargetException(e); + } + } + }; + } + + public String getFolderName() { + return fFolderName.getText(); + } + + public String getExistingFileName() { + return fExistingFileName.getText(); + } + + public boolean shouldUseExisting() { + return fUseExistingFileTick.isSelected(); + } + + public String getNewTypeName() { + return this.fTypeNameDialogField.getText(); + } + + public String[] getExtends() { + List elements = fSuperInterfacesDialogField.getElements(); + String[] elementNames = new String[elements.size()]; + for (int i = 0; i < elements.size(); i++) { + InterfaceWrapper element = (InterfaceWrapper) elements.get(i); + elementNames[i] = element.interfaceName; + } + return elementNames; + } + + // public boolean shouldGenComments() { + // return fAddCommentButton.isEnabled(); + // } +}
diff --git a/bundles/org.eclipse.wst.jsdt.web.ui/src/org/eclipse/wst/jsdt/internal/ui/wizards/dojo/SuperInterfaceSelectionDialog.java b/bundles/org.eclipse.wst.jsdt.web.ui/src/org/eclipse/wst/jsdt/internal/ui/wizards/dojo/SuperInterfaceSelectionDialog.java new file mode 100644 index 0000000..c2c0de4 --- /dev/null +++ b/bundles/org.eclipse.wst.jsdt.web.ui/src/org/eclipse/wst/jsdt/internal/ui/wizards/dojo/SuperInterfaceSelectionDialog.java
@@ -0,0 +1,223 @@ +/******************************************************************************* + * Copyright (c) 2008 IBM Corporation and others. + * All rights reserved. + *******************************************************************************/ +package org.eclipse.wst.jsdt.internal.ui.wizards.dojo; + +import java.util.Iterator; +import java.util.List; + +import org.eclipse.core.runtime.IStatus; +import org.eclipse.core.runtime.Status; +import org.eclipse.jface.dialogs.IDialogConstants; +import org.eclipse.jface.dialogs.IDialogSettings; +import org.eclipse.jface.operation.IRunnableContext; +import org.eclipse.jface.viewers.StructuredSelection; +import org.eclipse.swt.widgets.Button; +import org.eclipse.swt.widgets.Composite; +import org.eclipse.swt.widgets.Shell; +import org.eclipse.ui.PlatformUI; +import org.eclipse.wst.jsdt.core.IJavaScriptProject; +import org.eclipse.wst.jsdt.core.search.IJavaScriptSearchConstants; +import org.eclipse.wst.jsdt.core.search.IJavaScriptSearchScope; +import org.eclipse.wst.jsdt.core.search.SearchEngine; +import org.eclipse.wst.jsdt.core.search.TypeNameMatch; +import org.eclipse.wst.jsdt.internal.corext.util.JavaModelUtil; +import org.eclipse.wst.jsdt.internal.corext.util.Messages; +import org.eclipse.wst.jsdt.internal.ui.IJavaHelpContextIds; +import org.eclipse.wst.jsdt.internal.ui.JavaScriptPlugin; +import org.eclipse.wst.jsdt.internal.ui.dialogs.OpenTypeSelectionDialog; +import org.eclipse.wst.jsdt.internal.ui.dialogs.StatusInfo; + +/** + * A type selection dialog providing means to open interface(s). + */ +public class SuperInterfaceSelectionDialog extends OpenTypeSelectionDialog { + + private static final int ADD_ID = IDialogConstants.CLIENT_ID + 1; + + private NewTypeWizardPage fTypeWizardPage; + private List fOldContent; + + /** + * Creates new instance of SuperInterfaceSelectionDialog + * + * @param parent + * shell to parent the dialog on + * @param context + * context used to execute long-running operations associated + * with this dialog + * @param page + * page that opened this dialog + * @param p + * the java project which will be considered when searching for + * interfaces + */ + public SuperInterfaceSelectionDialog(Shell parent, + IRunnableContext context, NewTypeWizardPage page, IJavaScriptProject p) { + super(parent, true, context, createSearchScope(p), + IJavaScriptSearchConstants.CLASS); + fTypeWizardPage = page; + // to restore the content of the dialog field if the dialog is canceled + fOldContent = fTypeWizardPage.getSuperInterfaces(); + setStatusLineAboveButtons(true); + } + + /* + * (non-Javadoc) + * + * @see org.eclipse.ui.dialogs.SelectionDialog#createButtonsForButtonBar(org.eclipse.swt.widgets.Composite) + */ + protected void createButtonsForButtonBar(Composite parent) { + createButton(parent, ADD_ID, "&Add", true); + super.createButtonsForButtonBar(parent); + } + + /* + * (non-Javadoc) + * + * @see org.eclipse.jface.dialogs.Dialog#getDialogBoundsSettings() + */ + protected IDialogSettings getDialogBoundsSettings() { + return JavaScriptPlugin.getDefault().getDialogSettingsSection( + "DialogBounds_SuperInterfaceSelectionDialog"); //$NON-NLS-1$ + } + + /* + * (non-Javadoc) + * + * @see org.eclipse.ui.dialogs.SelectionStatusDialog#updateButtonsEnableState(org.eclipse.core.runtime.IStatus) + */ + protected void updateButtonsEnableState(IStatus status) { + super.updateButtonsEnableState(status); + Button addButton = getButton(ADD_ID); + if (addButton != null && !addButton.isDisposed()) + addButton.setEnabled(!status.matches(IStatus.ERROR)); + } + + /* + * (non-Javadoc) + * + * @see org.eclipse.jface.window.Window#handleShellCloseEvent() + */ + protected void handleShellCloseEvent() { + super.handleShellCloseEvent(); + // Handle the closing of the shell by selecting the close icon + fTypeWizardPage.setSuperInterfaces(fOldContent, true); + } + + /* + * (non-Javadoc) + * + * @see org.eclipse.jface.dialogs.Dialog#cancelPressed() + */ + protected void cancelPressed() { + fTypeWizardPage.setSuperInterfaces(fOldContent, true); + super.cancelPressed(); + } + + /* + * (non-Javadoc) + * + * @see org.eclipse.jface.dialogs.Dialog#buttonPressed(int) + */ + protected void buttonPressed(int buttonId) { + if (buttonId == ADD_ID) { + addSelectedInterfaces(); + } else { + super.buttonPressed(buttonId); + } + } + + /* + * (non-Javadoc) + * + * @see org.eclipse.ui.dialogs.SelectionStatusDialog#okPressed() + */ + protected void okPressed() { + addSelectedInterfaces(); + super.okPressed(); + } + + /* + * Adds selected interfaces to the list. + */ + private void addSelectedInterfaces() { + StructuredSelection selection = getSelectedItems(); + if (selection == null) + return; + for (Iterator iter = selection.iterator(); iter.hasNext();) { + Object obj = iter.next(); + if (obj instanceof TypeNameMatch) { + accessedHistoryItem(obj); + TypeNameMatch type = (TypeNameMatch) obj; + String qualifiedName = JavaModelUtil.getFullyQualifiedName(type + .getType()); + String message; + + if (fTypeWizardPage.addSuperInterface(qualifiedName)) { + message = Messages.format("\"{0}\" added.", qualifiedName); + } else { + message = Messages.format("\"{0}\" already in list.", + qualifiedName); + } + updateStatus(new StatusInfo(IStatus.INFO, message)); + } + } + } + + /* + * Creates a searching scope including only one project. + */ + private static IJavaScriptSearchScope createSearchScope(IJavaScriptProject p) { + return SearchEngine.createJavaSearchScope(new IJavaScriptProject[] { p }); + } + + /* + * (non-Javadoc) + * + * @see org.eclipse.ui.dialogs.FilteredItemsSelectionDialog#handleDoubleClick() + */ + protected void handleDoubleClick() { + buttonPressed(ADD_ID); + } + + /* + * (non-Javadoc) + * + * @see org.eclipse.ui.dialogs.FilteredItemsSelectionDialog#handleSelected(org.eclipse.jface.viewers.StructuredSelection) + */ + protected void handleSelected(StructuredSelection selection) { + super.handleSelected(selection); + + if (selection.size() == 0 + && fTypeWizardPage.getSuperInterfaces().size() > fOldContent + .size()) { + // overrides updateStatus() from handleSelected() if + // list of super interfaces was modified + // the <code>super.handleSelected(selection)</code> has to be + // called, because superclass implementation of this class updates + // state of the table. + + updateStatus(new Status(IStatus.OK, JavaScriptPlugin.getPluginId(), + IStatus.OK, "", null)); //$NON-NLS-1$ + + getButton(ADD_ID).setEnabled(false); + } else { + // if selection isn't empty, the add button should be enabled in + // exactly the same scenarios as the OK button + getButton(ADD_ID).setEnabled(getButton(OK).isEnabled()); + } + } + + /* + * (non-Javadoc) + * + * @see org.eclipse.wst.jsdt.internal.ui.dialogs.OpenTypeSelectionDialog2#configureShell(org.eclipse.swt.widgets.Shell) + */ + protected void configureShell(Shell newShell) { + super.configureShell(newShell); + PlatformUI.getWorkbench().getHelpSystem().setHelp(newShell, + IJavaHelpContextIds.SUPER_INTERFACE_SELECTION_DIALOG); + } +}
