[Smartfrog-checkins] core/extras/eclipse/smartfrog-plugin/smartfrog-plugin-project/src/org/smartfrog

SourceForge Headquarters 225 Broadway Suite 1600 San Diego, CA 92101 +1 (858) 454-5900

Update of /cvsroot/smartfrog/core/extras/eclipse/smartfrog-plugin/smartfrog-plugin-project/src/org/smartfrog/tools/eclipse/core/ui
In directory sc8-pr-cvs1.sourceforge.net:/tmp/cvs-serv1917/smartfrog-plugin/smartfrog-plugin-project/src/org/smartfrog/tools/eclipse/core/ui

Added Files:
	NewJavaProjectWizardBase.java NewJavaWizardPage.java 
	JavaPackagePage.java NewProjectCreationPage.java 
Log Message:
Plug-in project, init check-in

--- NEW FILE: NewProjectCreationPage.java ---

/** (C) Copyright 1998-2004 Hewlett-Packard Development Company, LP

This library is free software; you can redistribute it and/or
modify it under the terms of the GNU Lesser General Public
License as published by the Free Software Foundation; either
version 2.1 of the License, or (at your option) any later version.

This library is distributed in the hope that it will be useful,
but WITHOUT ANY WARRANTY; without even the implied warranty of
MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
Lesser General Public License for more details.

You should have received a copy of the GNU Lesser General Public
License along with this library; if not, write to the Free Software
Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA  02111-1307  USA

For more information: www.smartfrog.org

*/

package org.smartfrog.tools.eclipse.core.ui;

import org.eclipse.swt.widgets.Composite;
import org.eclipse.ui.dialogs.WizardNewProjectCreationPage;
import org.eclipse.ui.help.WorkbenchHelp;

import org.smartfrog.tools.eclipse.core.CoreUtilities;
import org.smartfrog.tools.eclipse.model.IHelpContextIds;

public class NewProjectCreationPage
    extends WizardNewProjectCreationPage
{
    /**
     * @param pageName
     */
    public NewProjectCreationPage(String pageName)
    {
        super(pageName);
    }

    protected boolean validatePage()
    {
        boolean ret = true;
        ret = super.validatePage();

        if (!isValidPrjName(this.getProjectName())) {
            setErrorMessage(CoreUtilities.getResourceString(
                    "NewProjectCreationPage.error.noSpecialCharsAllowed")); //$NON-NLS-1$

            ret = false;
        }

        return ret;
    }

    public void createControl(Composite parent) {
        super.createControl(parent);
    	WorkbenchHelp.setHelp(getControl(),
                IHelpContextIds.SMARTFROG_PROJECT_WIZARD_PAGE_HELP_ID);
    }

    /**
     * Valid project name has to be: digit,letter,"-" or "_"
     */
    public boolean isValidPrjName(String str)
    {
        boolean ret = true;

        for (int i = 0; i < str.length(); i++) {
            if (!Character.isLetterOrDigit(str.charAt(i)) &&
                    ( str.charAt(i) != '-' ) && ( str.charAt(i) != '_' )) {
                ret = false;

                break;
            }
        }

        return ret;
    }
}

--- NEW FILE: JavaPackagePage.java ---

/** (C) Copyright 1998-2004 Hewlett-Packard Development Company, LP

This library is free software; you can redistribute it and/or
modify it under the terms of the GNU Lesser General Public
License as published by the Free Software Foundation; either
version 2.1 of the License, or (at your option) any later version.

This library is distributed in the hope that it will be useful,
but WITHOUT ANY WARRANTY; without even the implied warranty of
MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
Lesser General Public License for more details.

You should have received a copy of the GNU Lesser General Public
License along with this library; if not, write to the Free Software
Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA  02111-1307  USA

For more information: www.smartfrog.org

*/

package org.smartfrog.tools.eclipse.core.ui;

import org.eclipse.core.runtime.IStatus;

import org.eclipse.jdt.core.JavaConventions;

import org.eclipse.jface.resource.ImageDescriptor;
import org.eclipse.jface.wizard.WizardPage;

import org.eclipse.swt.SWT;
import org.eclipse.swt.layout.GridData;
import org.eclipse.swt.layout.GridLayout;
import org.eclipse.swt.widgets.Button;
import org.eclipse.swt.widgets.Composite;
import org.eclipse.swt.widgets.Event;
import org.eclipse.swt.widgets.Group;
import org.eclipse.swt.widgets.Label;
import org.eclipse.swt.widgets.Listener;
import org.eclipse.swt.widgets.Text;

import org.smartfrog.tools.eclipse.core.CoreUtilities;

/**
 * A Wizard Page that allows the user to specify a Java package name.
 */
public class JavaPackagePage
    extends WizardPage
{
    /**
     * SIZING_TEXT_FIELD_WIDTH is the width of a Package Name field.
     */
    private static final int SIZING_TEXT_FIELD_WIDTH = 250;

    /**
     * Package Name controls
     */
    private Text fPackageNameField;
    private Label fPackageLabel;

    /**
     * The listener is used to validate the Java package name
     * entered by the user. Installed on the package name field.
     */
    private Listener locationModifyListener = new Listener() {
            public void handleEvent(Event e)
            {
                setPageComplete(validatePage());
            }
        };

    /**
     * Constructor for JavaPackagePage.
     * @param pageName
     */
    public JavaPackagePage(String pageName)
    {
        super(pageName);
    }

    /**
     * Method validatePage.
     * @return true if a valid package name has been specified.
     */
    private boolean validatePage()
    {
        boolean returnValue = true;

        setErrorMessage(null);
        setMessage(null);

        String packageName = fPackageNameField.getText();

        if (packageName.length() > 0) {
            IStatus s = JavaConventions.validatePackageName(packageName);
            int severity = s.getSeverity();

            if (severity != IStatus.OK) {
                setErrorMessage(s.getMessage());

                if (severity == IStatus.ERROR) {
                    returnValue = false;
                }
            }
        }

        return returnValue;
    }

    /**
     * Constructor for JavaPackagePage.
     * @param pageName
     * @param title
     * @param titleImage
     */
    public JavaPackagePage(String pageName, String title,
        ImageDescriptor titleImage)
    {
        super(pageName, title, titleImage);
    }

    /**
     * @see org.eclipse.jface.dialogs.IDialogPage#createControl(Composite)
     */
    public void createControl(Composite parent)
    {
        // Layout
        GridLayout layout = new GridLayout();
        layout.numColumns = 3;
        layout.verticalSpacing = 10;

        // Composite
        Composite composite = new Composite(parent, SWT.NULL);
        composite.setLayout(layout);
        composite.setLayoutData(new GridData(GridData.FILL_HORIZONTAL));
        setControl(composite);
        createPageLayout(composite);
    }

    private void createPageLayout(Composite composite)
    {
        createJavaPackageLayout(composite);
    }

    private void createJavaPackageLayout(Composite composite)
    {
        // Let the user to specify the package for the skeleton
        Composite pkgGroup = new Composite(composite, SWT.NONE);
        GridLayout layout = new GridLayout();
        layout.numColumns = 2;
        pkgGroup.setLayout(layout);
        pkgGroup.setLayoutData(new GridData(GridData.FILL_HORIZONTAL));

        fPackageLabel = new Label(pkgGroup, SWT.NONE);

        String packageLabelText = CoreUtilities.getResourceString(
                "Wizard.JavaPackagePagePackageFieldLabel"); //$NON-NLS-1$
        fPackageLabel.setText(packageLabelText);

        fPackageNameField = new Text(pkgGroup, SWT.BORDER);

        GridData data = new GridData(GridData.FILL_HORIZONTAL);
        data.widthHint = SIZING_TEXT_FIELD_WIDTH;
        fPackageNameField.setLayoutData(data);

        // Install the Listener
        fPackageNameField.addListener(SWT.Modify, locationModifyListener);

        fPackageNameField.setEnabled(true);
    }

    /**
     * Utility method that creates a group instance
     * and sets the default layout data.
     *
     * @param parent        the parent for the new composite
     * @param numColumns        the number of columns
     * @return                        the new group
     */
    private Group createGroup(Composite parent, int numColumns)
    {
        // Layout
        GridLayout layout = new GridLayout();
        layout.numColumns = numColumns;

        // Group
        Group group = new Group(parent, SWT.SHADOW_NONE);
        group.setLayout(layout);

        GridData data = new GridData(GridData.FILL_HORIZONTAL);
        data.horizontalSpan = 3;
        group.setLayoutData(data);

        return group;
    } // createGroup

    /**
     * Utility method that creates a button instance
     * and sets the default layout data.
     *
     * @param parent        the parent for the new label
     * @param text                the text for the new button
     * @return                        the new label
     */
    private Button createButton(Composite parent, String text, int style)
    {
        Button button = new Button(parent, style);
        button.setText(text);

        GridData data = new GridData(GridData.HORIZONTAL_ALIGN_FILL);
        button.setLayoutData(data);

        return button;
    } // createButton

    /**
     * Method getPackageName.
     * @return String - The name of the package the user has entered into
     * the field.
     */
    public String getPackageName()
    {
        return fPackageNameField.getText();
    }

    /**
     * @see org.eclipse.jface.dialogs.IDialogPage#setVisible(boolean)
     */
    public void setVisible(boolean visible)
    {
        super.setVisible(visible);

        if (visible) {
            fPackageNameField.setFocus();
        }
    }
}

--- NEW FILE: NewJavaWizardPage.java ---

/** (C) Copyright 1998-2004 Hewlett-Packard Development Company, LP

This library is free software; you can redistribute it and/or
modify it under the terms of the GNU Lesser General Public
License as published by the Free Software Foundation; either
version 2.1 of the License, or (at your option) any later version.

This library is distributed in the hope that it will be useful,
but WITHOUT ANY WARRANTY; without even the implied warranty of
MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
Lesser General Public License for more details.

You should have received a copy of the GNU Lesser General Public
License along with this library; if not, write to the Free Software
Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA  02111-1307  USA

For more information: www.smartfrog.org

*/

package org.smartfrog.tools.eclipse.core.ui;

import org.eclipse.core.resources.IWorkspaceRoot;
import org.eclipse.core.runtime.IPath;
import org.eclipse.core.runtime.Path;

import org.eclipse.jdt.core.IClasspathEntry;
import org.eclipse.jdt.core.JavaCore;
import org.eclipse.jdt.ui.wizards.NewJavaProjectWizardPage;

import org.eclipse.swt.widgets.Composite;
import org.eclipse.ui.dialogs.WizardNewProjectCreationPage;
import org.eclipse.ui.help.WorkbenchHelp;

import org.smartfrog.tools.eclipse.core.SDKEnvironment;
import org.smartfrog.tools.eclipse.model.IHelpContextIds;

/**
 *
 * An extension of the JDT's NewJavaProjectWizardPage that will
 * update the page's classpath information using the supplied SDKEnvironment
 * object.
 *
 * This class establishes a default Source directory (/src) and a default
 * Output directory (/bin). It does not read the Java Preferences to determine
 * the desired behavior (but probably should).
 *
 */
public class NewJavaWizardPage
    extends NewJavaProjectWizardPage
{
    private static final String DEFAULT_RELATIVE_SOURCE_FOLDER = "/src"; //$NON-NLS-1$
    private static final String DEFAULT_RELATIVE_BIN_FOLDER = "/bin"; //$NON-NLS-1$

    /**
     *
     */
    private SDKEnvironment fSDKEnvironment = null;
    private String[] fRelativeSourceFolder = null;
    private String fRelativeBinFolder = null;
    private boolean mCannotFindSmartFrogLib;

    /**
     * Constructor for NewIUMJavaWizardPage.
     * @param root - An instance of IWorkspaceRoot
     * @param mainpage - The initial page of the Wizard.
     * @param An SDKEnvironment implementor specific to an SDK.
     * @deprecated Use the constructor that allows the source
     * folder to be set.
     */
    public NewJavaWizardPage(IWorkspaceRoot root,
        WizardNewProjectCreationPage mainpage, SDKEnvironment env)
    {
        super(root, mainpage);
        setPageComplete(false);
        fSDKEnvironment = env;
        fRelativeSourceFolder = new String[ 1 ];
        fRelativeSourceFolder[ 0 ] = DEFAULT_RELATIVE_SOURCE_FOLDER;
        fRelativeBinFolder = DEFAULT_RELATIVE_BIN_FOLDER;
    }

    /**
     * Constructor for NewIUMJavaWizardPage.
     * @param root - An instance of IWorkspaceRoot
     * @param mainpage - The initial page of the Wizard.
     * @param An SDKEnvironment implementor specific to an SDK.
     * @param The folder to use as the source folder. Should
     * be relative to the project directory e.g. "/src". If null
     * then the default value of "/src" is used.
     */
    public NewJavaWizardPage(IWorkspaceRoot root,
        WizardNewProjectCreationPage mainpage, SDKEnvironment env,
        String[] relativeSourceFolder)
    {
        super(root, mainpage);
        setPageComplete(false);
        fSDKEnvironment = env;

        if (relativeSourceFolder != null) {
            fRelativeSourceFolder = relativeSourceFolder;
        } else {
            fRelativeSourceFolder = new String[ 1 ];
            fRelativeSourceFolder[ 0 ] = DEFAULT_RELATIVE_SOURCE_FOLDER;
        }

        fRelativeBinFolder = DEFAULT_RELATIVE_BIN_FOLDER;
    }

    /**
     * Constructor for NewIUMJavaWizardPage.
     * @param root - An instance of IWorkspaceRoot
     * @param mainpage - The initial page of the Wizard.
     * @param An SDKEnvironment implementor specific to an SDK.
     * @param The folder to use as the source folder.
     * @param The folder to use as the binary folder. Should
     * be relative to the project directory e.g. "/bin". If null
     * then the default value of "/bin" is used.
     */
    public NewJavaWizardPage(IWorkspaceRoot root,
        WizardNewProjectCreationPage mainpage, SDKEnvironment env,
        String[] relativeSourceFolder, String relativeBinFolder)
    {
        this(root, mainpage, env, relativeSourceFolder);

        if (relativeBinFolder != null) {
            fRelativeBinFolder = relativeBinFolder;
        } else {
            fRelativeBinFolder = DEFAULT_RELATIVE_BIN_FOLDER;
        }
    }

    public void createControl(Composite parent) {
        super.createControl(parent);
    	WorkbenchHelp.setHelp(getControl(),
                IHelpContextIds.SMARTFROG_PROJECT_JAVA_WIZARD_PAGE_HELP_ID);
    }
    /**
     * Creates classpath entries
     *
     * @param The source path to add.
     * @return the created class path entry array, or <code>null</code> if the array
     * was not created
     */
    public IClasspathEntry[] makeClassPathEntries()
    {
        IPath projectPath = getProjectHandle().getFullPath();
        IClasspathEntry[] cpe = null;
        IPath sourcePath = null;
        mCannotFindSmartFrogLib = false;

        try {
            IClasspathEntry[] sdkcpe = fSDKEnvironment.getClasspath();
            int start = 0;

            if (sdkcpe != null) {
                cpe =
                    new IClasspathEntry[ sdkcpe.length +
                    fRelativeSourceFolder.length ];
                System.arraycopy(sdkcpe, 0, cpe, 0, sdkcpe.length);

                start = sdkcpe.length;

                for (int i = 0; i < sdkcpe.length; i++) {
                    IPath path = sdkcpe[ i ].getPath();

                    if (false == path.toFile().exists()) {
                        mCannotFindSmartFrogLib = true;

                        break;
                    }
                }
            } else {
                cpe = new IClasspathEntry[ fRelativeSourceFolder.length ];
            }

            // Add the source path.
            for (int i = 0; i < fRelativeSourceFolder.length; i++) {
                sourcePath = projectPath.append(new Path(
                            fRelativeSourceFolder[ i ]));

                cpe[ start + i ] = JavaCore.newSourceEntry(sourcePath);
            }
        } catch (Exception e) {
            e.printStackTrace();
        }

        return cpe;
    }

    /**
     * Extend this method to set a user defined default class path or output location.
     *
     * @see org.eclipse.jface.dialogs.IDialogPage#setVisible(boolean)
     */
    public void setVisible(boolean visible)
    {
        if (visible) {
            IPath projectPath = getProjectHandle().getFullPath();
            IClasspathEntry[] cpe = makeClassPathEntries();

            if (cpe != null) {
                setDefaultClassPath(cpe, true);
            }

            // Due to a bug in the base class we need to always setup src and bin
            // directories.
            setDefaultOutputFolder(projectPath.append(
                    new Path(fRelativeBinFolder)));
        }

        super.setVisible(visible);

        if (true == mCannotFindSmartFrogLib) {
            setErrorMessage(
                "Cannot find the SmartFrog libraries, please set the path in SmartFrog Preferences page."); //$NON-NLS-1$
        }
    }

    /**
     * @return The project relative source path that was set by this page.
     */
    public String getSourcePath()
    {
        return fRelativeSourceFolder[ 0 ];
    }

    /**
     * @return The project relative output path that was set by this page.
     */
    public String getBinPath()
    {
        return fRelativeBinFolder;
    }
}

--- NEW FILE: NewJavaProjectWizardBase.java ---

/** (C) Copyright 1998-2004 Hewlett-Packard Development Company, LP

This library is free software; you can redistribute it and/or
modify it under the terms of the GNU Lesser General Public
License as published by the Free Software Foundation; either
version 2.1 of the License, or (at your option) any later version.

This library is distributed in the hope that it will be useful,
but WITHOUT ANY WARRANTY; without even the implied warranty of
MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
Lesser General Public License for more details.

You should have received a copy of the GNU Lesser General Public
License along with this library; if not, write to the Free Software
Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA  02111-1307  USA

For more information: www.smartfrog.org

*/

package org.smartfrog.tools.eclipse.core.ui;

import org.eclipse.core.resources.IFile;
import org.eclipse.core.resources.IFolder;
import org.eclipse.core.resources.IProject;
import org.eclipse.core.resources.IProjectDescription;
import org.eclipse.core.resources.IWorkspaceRoot;
import org.eclipse.core.resources.ResourcesPlugin;
import org.eclipse.core.runtime.CoreException;
import org.eclipse.core.runtime.IConfigurationElement;
import org.eclipse.core.runtime.IExecutableExtension;
import org.eclipse.core.runtime.IProgressMonitor;
import org.eclipse.core.runtime.NullProgressMonitor;
import org.eclipse.core.runtime.SubProgressMonitor;

import org.eclipse.jface.dialogs.MessageDialog;
import org.eclipse.jface.operation.IRunnableWithProgress;

import org.eclipse.ui.INewWizard;
import org.eclipse.ui.actions.WorkspaceModifyDelegatingOperation;
import org.eclipse.ui.dialogs.WizardNewProjectCreationPage;
import org.eclipse.ui.wizards.newresource.BasicNewProjectResourceWizard;
import org.eclipse.ui.wizards.newresource.BasicNewResourceWizard;

import org.smartfrog.tools.eclipse.core.CoreUtilities;
import org.smartfrog.tools.eclipse.core.SDKEnvironment;

import java.io.InputStream;

import java.lang.reflect.InvocationTargetException;

/**
 *
 * This class can be used as the base class for Wizards extending org.eclipse.ui.NewWizard
 * Subclasses can simply override the processPages methods (potentially using some of
 * the protected utility methods) to add any additional project specific info.
 *
 * Subclasses are also free to override the Wizard addPages method, but should
 * call super.addPages() as the first line in the method as this class provides
 * the pages that allow the user to specify the project name and the Java project
 * properties.
 *
 *
 */
abstract public class NewJavaProjectWizardBase
    extends BasicNewResourceWizard
    implements INewWizard, IExecutableExtension
{
    /**
     * The config element set during setInitializationData. Used in performFinish
     * to change the ending perspective to the value listed as finalPerspective
     * in the Wizard's Extension Definition (i.e. in plugin.xml)
     */
    private IConfigurationElement fConfigElement;

    /**
     * The new project creation page.
     */
    private WizardNewProjectCreationPage fProjectPage;

    /**
     * The Java Project Properties page
     */
    private NewJavaWizardPage fJavaPage;

    /**
     * The SDK Environment. This is passed into the CTOR.
     */
    private SDKEnvironment fSDKEnvironment;

    /**
     * The units of work to use in the call to
     * org.eclipse.core.runtime.IProgressMonitor#beginTask
     */
    private int fUnitsOfWork = IProgressMonitor.UNKNOWN;

    /**
     * Members to maintain the title and description to be used for
     * the Project and Java Properties pages.
     */
    private String fTitle = null;
    private String fDescription = null;

    /**
     * Static members
     */
    private final static String NEW_PROJECT_WIZARD_ID =
        "Wizard.NewProjectWizardID"; //$NON-NLS-1$
    private final static String NEW_PROJECT_WIZARD_TASK_TITLE =
        "Wizard.NewProjectWizardTaskTitle"; //$NON-NLS-1$
    private final static String NEW_PROJECT_WIZARD_DEFAULT_TITLE =
        "Wizard.NewProjectWizardDefaultTitle"; //$NON-NLS-1$
    private final static String NEW_PROJECT_WIZARD_DEFAULT_DESCRIPTION =
        "Wizard.NewProjectWizardDefaultDescription"; //$NON-NLS-1$
    private final static String NEW_PROJECT_WIZARD_WINDOW_TITLE =
        "Wizard.NewProjectWizardWindowTitle"; //$NON-NLS-1$
    private String[] fSourceFolder;
    private String fBinaryFolder;

    /**
     * Publically available CTOR for NewJavaProjectWizardBase.
     *
     * @param Object that satisfies the SDKEnvironment interface. Current functionality
     * is to allow subclasses to specify the Java classpath used on the Java Properties
     * page.
     *
     * @param Title to be used for the Project and Java Properties pages.
     * @param Description to be used for the Project and Java Properties pages.
     * @param The units of work to be used in the call to
     * org.eclipse.core.runtime.IProgressMonitor#beginTask
     */
    public NewJavaProjectWizardBase(SDKEnvironment env, String title,
        String description, int unitsOfWork)
    {
        super();
        initialize(env, title, description, null, unitsOfWork);
    }

    /**
     * Publically available CTOR for NewJavaProjectWizardBase.
     * Subsequent call to org.eclipse.core.runtime.IProgressMonitor#beginTask will
     * use IProgressMonitor.UNKNOWN as the parameter.
     *
     * @param Object that satisfies the SDKEnvironment interface. Current functionality
     * is to allow subclasses to specify the Java classpath used on the Java Properties
     * page.
     * @param Title to be used for the Project and Java Properties pages.
     * @param Description to be used for the Project and Java Properties pages.
     */
    public NewJavaProjectWizardBase(SDKEnvironment env, String title,
        String description)
    {
        super();
        initialize(env, title, description, null, IProgressMonitor.UNKNOWN);
    }

    /**
     * Publically available CTOR for NewJavaProjectWizardBase.
     * Subsequent call to org.eclipse.core.runtime.IProgressMonitor#beginTask will
     * use IProgressMonitor.UNKNOWN as the parameter.
     * Default title and descriptions will be used.
     *
     * @param Object that satisfies the SDKEnvironment interface. Current functionality
     * is to allow subclasses to specify the Java classpath used on the Java Properties
     * page.
     */
    public NewJavaProjectWizardBase(SDKEnvironment env)
    {
        super();
        initialize(env,
            CoreUtilities.getResourceString(NEW_PROJECT_WIZARD_DEFAULT_TITLE),
            CoreUtilities.getResourceString(
                NEW_PROJECT_WIZARD_DEFAULT_DESCRIPTION), null,
            IProgressMonitor.UNKNOWN);
    }

    /**
     * Default CTOR assumes that set methods will be called later. Useful for
     * the Extensible subclass.
     */
    protected NewJavaProjectWizardBase()
    {
        initialize(null,
            CoreUtilities.getResourceString(NEW_PROJECT_WIZARD_DEFAULT_TITLE),
            CoreUtilities.getResourceString(
                NEW_PROJECT_WIZARD_DEFAULT_DESCRIPTION), null,
            IProgressMonitor.UNKNOWN);
    }

    /**
     * Publically available CTOR for NewJavaProjectWizardBase.
     * Subsequent call to org.eclipse.core.runtime.IProgressMonitor#beginTask will
     * use IProgressMonitor.UNKNOWN as the parameter.
     *
     * @param Object that satisfies the SDKEnvironment interface. Current functionality
     * is to allow subclasses to specify the Java classpath used on the Java Properties
     * page.
     * @param Title to be used for the Project and Java Properties pages.
     * @param Description to be used for the Project and Java Properties pages.
     * @param The folder to use as the source folder. Should
     * be relative to the project directory e.g. "/src". If null
     * then the default value of "/src" is used.
     */
    public NewJavaProjectWizardBase(SDKEnvironment env, String title,
        String description, String[] sourceFolder)
    {
        super();
        initialize(env, title, description, sourceFolder,
            IProgressMonitor.UNKNOWN);
    }

    /**
     * Publically available CTOR for NewJavaProjectWizardBase.
     * Subsequent call to org.eclipse.core.runtime.IProgressMonitor#beginTask will
     * use IProgressMonitor.UNKNOWN as the parameter.
     *
     * @param Object that satisfies the SDKEnvironment interface. Current functionality
     * is to allow subclasses to specify the Java classpath used on the Java Properties
     * page.
     * @param Title to be used for the Project and Java Properties pages.
     * @param Description to be used for the Project and Java Properties pages.
     * @param The folder to use as the source folder. Should
     * be relative to the project directory e.g. "/src". If null
     * then the default value of "/src" is used.
     * @param The folder to use as the binary folder. Should
     * be relative to the project directory e.g. "/bin". If null
     * then the default value of "/bin" is used.
     */
    public NewJavaProjectWizardBase(SDKEnvironment env, String title,
        String description, String[] sourceFolder, String binaryFolder)
    {
        super();
        initialize(env, title, description, sourceFolder, binaryFolder,
            IProgressMonitor.UNKNOWN);
    }

    /**
     * Private method to initialize the instance variables.
     *
     * @param Object that satisfies the SDKEnvironment interface. Current functionality
     * is to allow subclasses to specify the Java classpath used on the Java Properties
     * page.
     * @param Title to be used for the Project and Java Properties pages.
     * @param Description to be used for the Project and Java Properties pages.
     * @param The folder to use as the source folder.
     * @param The units of work to be used in the call to
     * org.eclipse.core.runtime.IProgressMonitor#beginTask
     */
    private void initialize(SDKEnvironment env, String title,
        String description, String[] sourceFolder, int unitsOfWork)
    {
        fSDKEnvironment = env;
        fTitle = title;
        fDescription = description;
        fUnitsOfWork = unitsOfWork;
        fSourceFolder = sourceFolder;
        setWindowTitle(CoreUtilities.getResourceString(
                NEW_PROJECT_WIZARD_WINDOW_TITLE));
    }

    /**
     * Private method to initialize the instance variables.
     *
     * @param Object that satisfies the SDKEnvironment interface. Current functionality
     * is to allow subclasses to specify the Java classpath used on the Java Properties
     * page.
     * @param Title to be used for the Project and Java Properties pages.
     * @param Description to be used for the Project and Java Properties pages.
     * @param The folder to use as the source folder.
     * @param The folder to use as the binary folder.
     * @param The units of work to be used in the call to
     * org.eclipse.core.runtime.IProgressMonitor#beginTask
     */
    private void initialize(SDKEnvironment env, String title,
        String description, String[] sourceFolder, String binaryFolder,
        int unitsOfWork)
    {
        this.initialize(env, title, description, sourceFolder, unitsOfWork);
        fBinaryFolder = binaryFolder;
    }

    /**
     * @see org.eclipse.jface.wizard.IWizard#addPages()
     *
     * Calls the base class's addPages and then creates and adds pages
     * for Project creation and the Java Properties settings.
     */
    public void addPages()
    {
        super.addPages();

        fProjectPage = new NewProjectCreationPage(CoreUtilities
                .getResourceString(NEW_PROJECT_WIZARD_ID));

        fProjectPage.setTitle(fTitle);

        fProjectPage.setDescription(fDescription);
        this.addPage(fProjectPage);

        //add the second page
        IWorkspaceRoot root = ResourcesPlugin.getWorkspace().getRoot();

        fJavaPage = new NewJavaWizardPage(root, fProjectPage, fSDKEnvironment,
                fSourceFolder, fBinaryFolder);

        fJavaPage.setTitle(fTitle);

        fJavaPage.setDescription(fDescription);
        addPage(fJavaPage);
    }

    /**
     * Delete any resources.
     * This method is final and only public since it must be called by the
     * Framework.
     *
     * @see org.eclipse.jface.wizard.IWizard#dispose()
     */
    public final void dispose()
    {
        super.dispose();
        fSDKEnvironment = null;
        fTitle = null;
        fDescription = null;
    }

    /**
     * @see org.eclipse.jface.wizard.IWizard#performFinish()
     *
     *        The user has pressed Finish.  Instruct self's pages to finish, and
     *        answer a boolean indicating success.
     *
     * This method is final and only public since it must be called by the
     * Framework when the user selects the Finish button. Rather than overriding
     * this method, subclasses implement the processPages method.
     *
     * This method uses Eclipse classes to modify the workspace.
     * Uses these classes it calls the runnable in the Java Properties page
     * to establish the Java settings, then it will call the runnable
     * that wraps the call to the subclasses processPages method.
     *
     *        @return True if all was OK, False if either the user canceled or an error
     * occurred.
     */
    public boolean performFinish()
    {
        IRunnableWithProgress javaop = new WorkspaceModifyDelegatingOperation(
                fJavaPage.getRunnable());
        IRunnableWithProgress op = new WorkspaceModifyDelegatingOperation(
                getRunnable());

        try {
            getContainer().run(false, true, javaop);
            getContainer().run(false, true, op);
        } catch (InvocationTargetException e) {
            InvocationTargetExceptionHandler(e);

            return false;
        } catch (InterruptedException e) {
            return false;
        }

        // Everyting was successful assure that the perspective switches
        // to the Resource perspective and that the project is revealed.
        BasicNewProjectResourceWizard.updatePerspective(fConfigElement);
        selectAndReveal(getNewProject());

        return true;
    }

    /**
     * @see org.eclipse.core.runtime.IExecutableExtension#setInitializationData(IConfigurationElement, String, Object)
     *
     *
     * Stores the configuration element for the wizard.  The config element will be used
     * in <code>performFinish</code> to set the result perspective.
     *
     *
     */
    public void setInitializationData(IConfigurationElement cfig,
        String propertyName, Object data)
        throws CoreException
    {
        fConfigElement = cfig;
    }

    /**
     * @see org.eclipse.ui.wizards.newresource.BasicNewProjectResourceWizard#getNewProject()
     *
     * This method is final and only public since it is defined as such by super.
     */
    public final IProject getNewProject()
    {
        return fProjectPage.getProjectHandle();
    }

    /**
     *         Provides the IRunnableWithProgress instance that is used
     *  for calling the subclass's processPages method.
     *
     * The IRunnableWithProgress#run method will call the subclasses processPages.
     * It will delete the project that has been created by the Project page if there
     * is any CoreException thrown from processPages.
     *
     * @exception Wrapper exception for any CoreException that may have happened during
     * the call to processPages.
     * @exception User canceled the operation.
     *
     * @see org.eclipse.core.runtime.IProgressMonitor.
     * @see org.eclipse.jface.operation.IRunnableWithProgress
     */
    private IRunnableWithProgress getRunnable()
    {
        return new IRunnableWithProgress() {
                public void run(IProgressMonitor monitor)
                    throws InvocationTargetException, InterruptedException
                {
                    if (monitor == null) {
                        monitor = new NullProgressMonitor();
                    }

                    monitor.beginTask(CoreUtilities.getResourceString(
                            NEW_PROJECT_WIZARD_TASK_TITLE), fUnitsOfWork);

                    try {
                        processPages(getNewProject(), monitor);
                    }
                    // WIth any type of CoreException remove the project from the Workspace
                    // and then throw the InvocationTargetException to performFinish
                    // THis will force a message to the user and a return
                    // to the last page of the Wizard
                    catch (CoreException e) {
                        removeProject(monitor);
                        throw new InvocationTargetException(e);
                    } finally {
                        if (monitor != null) {
                            monitor.done();
                        }
                    }
                }
            };
    }

    /**
     *         Removes this Wizard's project resource from the Workspace. Subclasses cannot
     * use this method and instead should throw a Throwable from their processPages
     * implementation
     *
     * @param monitor - A progress monitor
     *
     * @exception InvocationTargetException - Any exception is wrapped with
     * the InvocationTargetException so it is caught during performFinish.
     *
     */
    private void removeProject(IProgressMonitor monitor)
        throws InvocationTargetException
    {
        IProject project = getNewProject();

        if (project != null) {
            try {
                // Assure that we do not delete any filesystem resources that
                // may have existed in the project's directory. For example,
                // if the file <project name>.wsdl existed the Wizard will fail
                // but we cannot remove this file.
                project.delete(false, false,
                    new SubProgressMonitor(monitor, 1));
            } catch (Exception e) {
                throw new InvocationTargetException(e);
            }
        }
    }

    /**
     * processPages must be overriden by a subclass. It is in this method
     * that the subclass should do any specific processing it requires.
     *
     * @param The project instance that has been created. All information
     * known by this base class is contained in the IProject or the retrievable
     * IProjectDescription. Note that if processPages throws a CoreException
     * the project will be removed and the project handle will be invalid.
     *
     * @param Subclasses can indicate progress using this object's worked method.
     *
     * @see org.eclipse.core.runtime.IProgressMonitor
     */
    abstract protected void processPages(IProject p, IProgressMonitor monitor)
        throws CoreException;

    /**
     * A utility method for adding an Eclipse nature to the created project
     * By default the created project will already have the Java nature, so this
     * method need only be used if the subclass wishes to add other natures.
     *
     * @param The nature id as listed in plugin.xml.
     *
     * @exception An exception thrown from either IProject#getDescription or IProject#setDescription
     *
     * @see org.eclipse.core.runtime.CoreException
     * @see org.eclipse.core.resources.IProject#getDescription
     * @see org.eclipse.core.resource.IProject#setDescription
     */
    protected final void addNature(String nature)
        throws CoreException
    {
        addNature(getNewProject(), nature);
    }

    /**
     * An accompanying private addNature that allows the code base to be shared.
     *
     */
    private static void addNature(IProject p, String nature)
        throws CoreException
    {
        IProjectDescription description = p.getDescription();
        String[] natures = description.getNatureIds();
        String[] newNatures = new String[ natures.length + 1 ];
        System.arraycopy(natures, 0, newNatures, 0, natures.length);
        newNatures[ natures.length ] = nature;
        description.setNatureIds(newNatures);
        p.setDescription(description, null);
    }

    /**
     * A utility method that will create a file in the Project's root.
     *
     * @param The InputStream that is to be used as the initial contents of the file.
     * This parameter should not be null.
     * @param The name to give the file.
     * @param An IProgresMonitor to be used in calls to the Framework.
     *
     * @exception An exception thrown from either IFile#create
     *
     * @see org.eclipse.core.runtime.CoreException
     * @see org.eclipse.core.resources.IFile#create
     */
    protected final void createProjectFile(InputStream s, String name,
        IProgressMonitor monitor)
        throws CoreException
    {
        IFile f = getNewProject().getFile(name);
        createFile(f, s, monitor);
    }

    /**
     * A utility method for creating a file in the Project's default source
     * folder (i.e. /src)
     * @param The InputStream that is to be used as the initial contents of the file.
     * This parameter should not be null.
     * @param The name to give the file.
     * @param The package name for the source file. If this is not null or the
     * empty string then this method will create the appropriate folder structure
     * under the Project.
     * @param An IProgresMonitor to be used in calls to the Framework.
     *
     * @exception An exception thrown from either IFolder#create or IFile#create
     *
     * @see org.eclipse.core.runtime.CoreException
     * @see org.eclipse.core.resources.IFile#create
     * @see org.eclipse.core.resource.IFolder#create
     */
    protected final void createSourceFile(InputStream s, String name,
        String packageName, IProgressMonitor monitor)
        throws CoreException
    {
        String folderName = fJavaPage.getSourcePath();

        if (( packageName != null ) && ( packageName.length() > 0 )) {
            createFolder(folderName, monitor);

            // Setup for the case where the package name is a single word
            int start = 0;
            int index = packageName.indexOf('.', start);

            if (index == -1) {
                folderName += ( "/" + packageName ); //$NON-NLS-1$
            }

            while (index != -1) {
                folderName += ( "/" + packageName.substring(start, index) ); //$NON-NLS-1$

                createFolder(folderName, monitor);
                start = index + 1;
                index = packageName.indexOf('.', start);

                if (index == -1) {
                    // Last Folder Name should be used as the parameter to the createFileInFolder
                    // method.
                    folderName += ( "/" + packageName.substring(start) ); //$NON-NLS-1$
                }
            }
        }

        createFileInFolder(s, folderName, name, monitor);
    }

    /**
     * A utility method for creating a file in a first-level arbitrary Project folder.
     *
     * @param The InputStream that is to be used as the initial contents of the file.
     * This parameter should not be null.
     * @param The path of the folder (e.g. /test). The folder will be created if it does not
     * exist. Note that for now there is only support for one level below the project.
     * @param The name to give the file.
     * @param An IProgresMonitor to be used in calls to the Framework.
     *
     * @exception An exception thrown from either IFolder#create or IFile#create
     *
     * @see org.eclipse.core.runtime.CoreException
     * @see org.eclipse.core.resources.IFile#create
     * @see org.eclipse.core.resource.IFolder#create
     */
    protected final void createFileInFolder(InputStream s, String folderName,
        String name, IProgressMonitor monitor)
        throws CoreException
    {
        IFile file = createFolder(folderName, monitor).getFile(name);
        createFile(file, s, monitor);
    }

    /**
     * A utility method for creating a folder under the Project.
     *
     * @param The path of the folder (e.g. /test). The folder will be created if it does not
     * exist. Note that for now there is only support for one level below the project.
     * @param An IProgresMonitor to be used in calls to the Framework.
     *
     * @exception An exception thrown from IFolder#create
     *
     * @see org.eclipse.core.runtime.CoreException
     * @see org.eclipse.core.resources.IFolder#create
     */
    protected final IFolder createFolder(String folderName,
        IProgressMonitor monitor)
        throws CoreException
    {
        return createFolder(getNewProject(), folderName, monitor);
    }

    /**
     * An accompanying private createFolder that allows the code base to be shared.
     *
     */
    private static IFolder createFolder(IProject p, String folderName,
        IProgressMonitor monitor)
        throws CoreException
    {
        IFolder folder = p.getFolder(folderName);

        if (!folder.exists()) {
            folder.create(true, true, monitor);
        }

        return folder;
    }

    /**
     * A utility method for creating a file in the Workspace.
     *
     * @param The IFile representation of the file. This has been obtained from
     * a Framework call (e.g. IProject#getFile(filename) )
     * @param An IProgresMonitor to be used in calls to the Framework.
     *
     * @exception An exception thrown from IFile#create
     *
     * @see org.eclipse.core.runtime.CoreException
     * @see org.eclipse.core.resources.IFile#create
     */
    protected final void createFile(IFile f, InputStream s,
        IProgressMonitor monitor)
        throws CoreException
    {
        if (!f.exists()) {
            f.create(s, false, monitor);
        }
    }

    /**
     * Returns the name of the Project.
     *
     * @return The name of the project. This is the value the
     * user typed into the Project page.
     * @exception An exception thrown from either IProject#getDescription
     *
     * @see org.eclipse.core.runtime.CoreException
     * @see org.eclipse.core.resources.IProject#getDescription
     *
     */
    protected final String getProjectName()
        throws CoreException
    {
        IProject p = getNewProject();

        if (p != null) {
            IProjectDescription pd = p.getDescription();

            if (pd != null) {
                return pd.getName();
            }
        }

        return ""; //$NON-NLS-1$
    }

    /**
     *         Display messages based on e
     *
     * @param e, an InvocationTargetException to tell the user about.
     */
    private void InvocationTargetExceptionHandler(InvocationTargetException e)
    {
        MessageDialog.openError(getShell(), fTitle,
            e.getTargetException().getMessage());
    }

    /**
     * Sets the fSDKEnvironment.
     * @param fSDKEnvironment The fSDKEnvironment to set
     */
    protected void setFSDKEnvironment(SDKEnvironment fSDKEnvironment)
    {
        this.fSDKEnvironment = fSDKEnvironment;
    }

    /**
     * Sets the fTitle.
     * @param fTitle The fTitle to set
     */
    protected void setFTitle(String fTitle)
    {
        this.fTitle = fTitle;
    }

    /**
     * Sets the fDescription.
     * @param fDescription The fDescription to set
     */
    public void setFDescription(String fDescription)
    {
        this.fDescription = fDescription;
    }
}

[Smartfrog-checkins] core/extras/eclipse/smartfrog-plugin/smartfrog-plugin-project/src/org/smartfrog

[Smartfrog-checkins] core/extras/eclipse/smartfrog-plugin/smartfrog-plugin-project/src/org/smartfrog/tools/eclipse/core/ui NewJavaProjectWizardBase.java,NONE,1.1 NewJavaWizardPage.java,NONE,1.1 JavaPackagePage.java,NONE,1.1 NewProjectCreationPage.java,NONE,1.1