Example usage for org.eclipse.jdt.core IJavaProject findPackageFragmentRoot

List of usage examples for org.eclipse.jdt.core IJavaProject findPackageFragmentRoot

Introduction

In this page you can find the example usage for org.eclipse.jdt.core IJavaProject findPackageFragmentRoot.

Prototype

IPackageFragmentRoot findPackageFragmentRoot(IPath path) throws JavaModelException;

Source Link

Document

Returns the existing package fragment root on this project's classpath whose path matches the given (absolute) path, or null if one does not exist.

Usage

From source file:at.bestsolution.efxclipse.tooling.ui.wizards.AbstractHtmlElementPage.java

License:Open Source License

private IPackageFragmentRoot choosePackageRoot() {
    IJavaElement initElement = clazz.getFragmentRoot();
    Class<?>[] acceptedClasses = new Class<?>[] { IPackageFragmentRoot.class, IJavaProject.class };
    TypedElementSelectionValidator validator = new TypedElementSelectionValidator(acceptedClasses, false) {
        public boolean isSelectedValid(Object element) {
            try {
                if (element instanceof IJavaProject) {
                    IJavaProject jproject = (IJavaProject) element;
                    IPath path = jproject.getProject().getFullPath();
                    return (jproject.findPackageFragmentRoot(path) != null);
                } else if (element instanceof IPackageFragmentRoot) {
                    return (((IPackageFragmentRoot) element).getKind() == IPackageFragmentRoot.K_SOURCE);
                }/* w  ww .  jav  a 2s  .  c  o  m*/
                return true;
            } catch (JavaModelException e) {
                JavaPlugin.log(e.getStatus()); // just log, no UI in validation
            }
            return false;
        }
    };

    acceptedClasses = new Class[] { IJavaModel.class, IPackageFragmentRoot.class, IJavaProject.class };
    ViewerFilter filter = new TypedViewerFilter(acceptedClasses) {
        public boolean select(Viewer viewer, Object parent, Object element) {
            if (element instanceof IPackageFragmentRoot) {
                try {
                    return (((IPackageFragmentRoot) element).getKind() == IPackageFragmentRoot.K_SOURCE);
                } catch (JavaModelException e) {
                    JavaPlugin.log(e.getStatus()); // just log, no UI in validation
                    return false;
                }
            }
            return super.select(viewer, parent, element);
        }
    };

    StandardJavaElementContentProvider provider = new StandardJavaElementContentProvider();
    ILabelProvider labelProvider = new JavaElementLabelProvider(JavaElementLabelProvider.SHOW_DEFAULT);
    ElementTreeSelectionDialog dialog = new ElementTreeSelectionDialog(getShell(), labelProvider, provider);
    dialog.setValidator(validator);
    dialog.setComparator(new JavaElementComparator());
    dialog.setTitle(NewWizardMessages.NewContainerWizardPage_ChooseSourceContainerDialog_title);
    dialog.setMessage(NewWizardMessages.NewContainerWizardPage_ChooseSourceContainerDialog_description);
    dialog.addFilter(filter);
    dialog.setInput(JavaCore.create(fWorkspaceRoot));
    dialog.setInitialSelection(initElement);
    dialog.setHelpAvailable(false);

    if (dialog.open() == Window.OK) {
        Object element = dialog.getFirstResult();
        if (element instanceof IJavaProject) {
            IJavaProject jproject = (IJavaProject) element;
            return jproject.getPackageFragmentRoot(jproject.getProject());
        } else if (element instanceof IPackageFragmentRoot) {
            return (IPackageFragmentRoot) element;
        }
        return null;
    }
    return null;
}

From source file:ccw.launching.LaunchUtils.java

License:Open Source License

private static IPackageFragmentRoot findPackageFragmentRoot(IJavaProject javaProject, IPath filePath)
        throws JavaModelException {
    if (filePath.isEmpty() || filePath.isRoot()) {
        return null;
    } else {//from w  ww  .  j  ava2s . c o m
        IResource possibleFragmentResource = ResourcesPlugin.getWorkspace().getRoot()
                .getFileForLocation(filePath);
        if (possibleFragmentResource != null) {
            filePath = possibleFragmentResource.getFullPath();
        }
        IPackageFragmentRoot fragment = javaProject.findPackageFragmentRoot(filePath);
        if (fragment != null) {
            return fragment;
        } else {
            return findPackageFragmentRoot(javaProject, filePath.removeLastSegments(1));
        }
    }
}

From source file:com.aliyun.odps.eclipse.utils.NewWizardUtils.java

License:Apache License

public static void createClass(IJavaProject myjavapro, String className, String classPath,
        IProgressMonitor monitor, String content) throws JavaModelException {
    IPath mypath = myjavapro.getPath();//from  w  w  w.j a  va  2s  . c o  m
    mypath = mypath.append("src");
    mypath.append(classPath);
    IPackageFragmentRoot fragmentRoot = myjavapro.findPackageFragmentRoot(mypath);
    IPackageFragment fragment = fragmentRoot.createPackageFragment(classPath, true, monitor);
    fragment.createCompilationUnit(className + ".java", content, true, monitor);
}

From source file:com.aliyun.odps.eclipse.utils.NewWizardUtils.java

License:Apache License

public static void createTestBase(IJavaProject myjavapro, String classPath, IProgressMonitor monitor,
        String content, String testBaseName) throws JavaModelException {
    IPath mypath = myjavapro.getPath();//from  www . j  a  va2  s  .c o m
    mypath = mypath.append("src");
    mypath.append(classPath);

    IPackageFragmentRoot fragmentRoot = myjavapro.findPackageFragmentRoot(mypath);
    IPackageFragment fragment = fragmentRoot.createPackageFragment(classPath, true, monitor);
    IJavaElement[] iJavaElement = fragment.getChildren();
    boolean exit = false;
    for (int i = 0; i < iJavaElement.length; i++) {
        if (iJavaElement[i].getElementName().equals(testBaseName)) {
            exit = true;
            break;
        }
    }
    if (!exit) {
        fragment.createCompilationUnit(testBaseName, content, false, monitor);
    }
}

From source file:com.codenvy.ide.ext.java.server.internal.core.DeltaProcessor.java

License:Open Source License

private void checkSourceAttachmentChange(IResourceDelta delta, File res) {
    IPath rootPath = (IPath) this.state.sourceAttachments.get(externalPath(res));
    if (rootPath != null) {
        RootInfo rootInfo = rootInfo(rootPath, delta.getKind());
        if (rootInfo != null) {
            IJavaProject projectOfRoot = rootInfo.project;
            IPackageFragmentRoot root = null;
            try {
                // close the root so that source attachment cache is flushed
                root = projectOfRoot.findPackageFragmentRoot(rootPath);
                if (root != null) {
                    root.close();/*from   w ww  . j ava2 s  .c  o  m*/
                }
            } catch (JavaModelException e) {
                // root doesn't exist: ignore
            }
            if (root == null)
                return;
            switch (delta.getKind()) {
            case IResourceDelta.ADDED:
                currentDelta().sourceAttached(root);
                break;
            case IResourceDelta.CHANGED:
                currentDelta().sourceDetached(root);
                currentDelta().sourceAttached(root);
                break;
            case IResourceDelta.REMOVED:
                currentDelta().sourceDetached(root);
                break;
            }
        }
    }
}

From source file:com.google.gdt.eclipse.appengine.rpc.wizards.RPCWizardUISupport.java

License:Open Source License

public IPackageFragmentRoot chooseContainer(IType type) {

    Class<?>[] acceptedClasses = new Class[] { IPackageFragmentRoot.class, IJavaProject.class };
    TypedElementSelectionValidator validator = new TypedElementSelectionValidator(acceptedClasses, false) {
        @Override//  ww  w . ja  va2 s. c om
        public boolean isSelectedValid(Object element) {
            try {
                if (element instanceof IJavaProject) {
                    IJavaProject jproject = (IJavaProject) element;
                    IPath path = jproject.getProject().getFullPath();
                    return (jproject.findPackageFragmentRoot(path) != null);
                } else if (element instanceof IPackageFragmentRoot) {
                    return (((IPackageFragmentRoot) element).getKind() == IPackageFragmentRoot.K_SOURCE);
                }
                return true;
            } catch (JavaModelException e) {
                AppEngineRPCPlugin.log(e);
            }
            return false;
        }
    };

    acceptedClasses = new Class[] { IJavaModel.class, IPackageFragmentRoot.class, IJavaProject.class };
    ViewerFilter filter = new TypedViewerFilter(acceptedClasses) {
        @Override
        public boolean select(Viewer viewer, Object parent, Object element) {

            // only show appengine projects
            if (element instanceof IJavaProject) {
                IJavaProject jp = (IJavaProject) element;
                return isAppEngineProject(jp.getProject());
            }

            // only show source folders
            if (element instanceof IPackageFragmentRoot) {
                try {
                    return (((IPackageFragmentRoot) element).getKind() == IPackageFragmentRoot.K_SOURCE);
                } catch (JavaModelException e) {
                    AppEngineRPCPlugin.log(e);
                    return false;
                }
            }
            return super.select(viewer, parent, element);
        }
    };

    StandardJavaElementContentProvider provider = new StandardJavaElementContentProvider();
    ILabelProvider labelProvider = new JavaElementLabelProvider(JavaElementLabelProvider.SHOW_DEFAULT);
    ElementTreeSelectionDialog dialog = new ElementTreeSelectionDialog(getShell(), labelProvider, provider);
    dialog.setValidator(validator);
    dialog.setComparator(new JavaElementComparator());
    dialog.setTitle("Source Folder Selection"); //$NON-NLS-1$
    dialog.setMessage("&Choose a source folder:"); //$NON-NLS-1$
    dialog.addFilter(filter);
    dialog.setInput(JavaCore.create(ResourcesPlugin.getWorkspace().getRoot()));
    if (type != null) {
        dialog.setInitialSelection(JavaUtils.getPackageFragmentRoot(type));
    }
    dialog.setHelpAvailable(false);

    if (dialog.open() == Window.OK) {
        Object element = dialog.getFirstResult();
        if (element instanceof IJavaProject) {
            IJavaProject jproject = (IJavaProject) element;
            return jproject.getPackageFragmentRoot(jproject.getProject());
        } else if (element instanceof IPackageFragmentRoot) {
            return (IPackageFragmentRoot) element;
        }
        return null;
    }
    return null;
}

From source file:com.google.gdt.eclipse.core.JavaProjectTestUtilities.java

License:Open Source License

/**
 * Creates an {@link ICompilationUnit} with the given fully qualified name and
 * code in the <code>javaProject</code>.
 * /*from  w  ww  .  j  a v a2s.  c om*/
 * @param javaProject java project to host the new class
 * @param fullyQualifiedClassName fully qualified name for the class
 * @param source code for the classs
 * @return newly created {@link ICompilationUnit}
 * @throws JavaModelException
 */
public static ICompilationUnit createCompilationUnit(IJavaProject javaProject, String fullyQualifiedClassName,
        String source) throws JavaModelException {
    IPackageFragmentRoot root = javaProject.findPackageFragmentRoot(javaProject.getPath());
    if (root == null) {
        addRawClassPathEntry(javaProject, JavaCore.newSourceEntry(javaProject.getPath()));
        root = javaProject.findPackageFragmentRoot(javaProject.getPath());
    }

    String qualifier = Signature.getQualifier(fullyQualifiedClassName);
    IProgressMonitor monitor = new NullProgressMonitor();
    IPackageFragment packageFragment = root.createPackageFragment(qualifier, true, monitor);
    String name = Signature.getSimpleName(fullyQualifiedClassName);
    return packageFragment.createCompilationUnit(name + ".java", source, false, monitor);
}

From source file:com.google.gdt.eclipse.core.JavaProjectUtilities.java

License:Open Source License

/**
 * Creates an {@link ICompilationUnit} with the given fully qualified name and
 * code in the <code>javaProject</code>.
 *
 * @param javaProject java project to host the new class
 * @param fullyQualifiedClassName fully qualified name for the class
 * @param source code for the classs/* w ww.jav  a 2s . c  o m*/
 * @return newly created {@link ICompilationUnit}
 * @throws JavaModelException
 */
public static ICompilationUnit createCompilationUnit(IJavaProject javaProject, String fullyQualifiedClassName,
        String source) throws JavaModelException {
    IPackageFragmentRoot root = javaProject.findPackageFragmentRoot(javaProject.getPath());
    if (root == null) {
        addRawClassPathEntry(javaProject, JavaCore.newSourceEntry(javaProject.getPath()));
        root = javaProject.findPackageFragmentRoot(javaProject.getPath());
    }

    String qualifier = Signature.getQualifier(fullyQualifiedClassName);
    IProgressMonitor monitor = new NullProgressMonitor();
    IPackageFragment packageFragment = root.createPackageFragment(qualifier, true, monitor);
    String name = Signature.getSimpleName(fullyQualifiedClassName);
    ICompilationUnit cu = packageFragment.createCompilationUnit(name + ".java", source, false, monitor);
    JobsUtilities.waitForIdle();
    return cu;
}

From source file:com.google.gdt.eclipse.designer.core.nls.GwtSourceTest.java

License:Open Source License

@DisposeProjectAfter
public void test_create() throws Exception {
    // recreate project
    {/*  ww w  .  j av a2 s .c o  m*/
        tearDown();
        do_projectDispose();
        setUp();
    }
    // parse
    RootPanelInfo frame = parseJavaInfo("public class Test implements EntryPoint {",
            "  public void onModuleLoad() {", "    RootPanel rootPanel = RootPanel.get();",
            "    rootPanel.setTitle('My title');", "  }", "}");
    NlsSupport support = NlsSupport.get(frame);
    IEditableSupport editableSupport = support.getEditable();
    // prepare editable source
    IEditableSource editableSource = NlsTestUtils.createEmptyEditable("test.client.MyConstants");
    editableSource.setKeyGeneratorStrategy(GwtSource.GWT_KEY_GENERATOR);
    // prepare parameters
    SourceParameters parameters = new SourceParameters();
    IJavaProject javaProject = m_lastEditor.getJavaProject();
    {
        parameters.m_constant = new SourceClassParameters();
        SourceClassParameters constant = parameters.m_constant;
        constant.m_sourceFolder = javaProject.findPackageFragmentRoot(new Path("/TestProject/src"));
        constant.m_package = javaProject.findPackageFragment(new Path("/TestProject/src/test/client"));
        constant.m_packageFolder = (IFolder) constant.m_package.getUnderlyingResource();
        constant.m_packageName = constant.m_package.getElementName();
        constant.m_className = "MyConstants";
        constant.m_fullClassName = "test.client.MyConstants";
        constant.m_exists = false;
    }
    parameters.m_fieldName = "CONSTANTS";
    // add source
    {
        SourceDescription sourceDescription = new SourceDescription(GwtSource.class,
                GwtSourceNewComposite.class);
        editableSupport.addSource(editableSource, sourceDescription, parameters);
    }
    // do externalize
    StringPropertyInfo propertyInfo = editableSupport.getProperties(frame).get(0);
    editableSupport.externalizeProperty(propertyInfo, editableSource, true);
    // apply commands
    support.applyEditable(editableSupport);
    // checks
    assertEditor("public class Test implements EntryPoint {",
            "  private static final MyConstants CONSTANTS = GWT.create(MyConstants.class);",
            "  public void onModuleLoad() {", "    RootPanel rootPanel = RootPanel.get();",
            "    rootPanel.setTitle(CONSTANTS.rootPanel_title());", "  }", "}");
    // Constants
    {
        String messages = getFileContentSrc("test/client/MyConstants.java");
        messages = StringUtils.replace(messages, "\r\n", "\n");
        assertEquals(
                getSourceDQ("package test.client;", "", "import com.google.gwt.i18n.client.Constants;", "",
                        "public interface MyConstants extends Constants {", "  String rootPanel_title();", "}"),
                messages);
    }
    // *.properties
    {
        String newProperties = getFileContentSrc("test/client/MyConstants.properties");
        assertTrue(newProperties.contains("#GWT variable: CONSTANTS"));
        assertTrue(newProperties.contains("rootPanel_title=My title"));
    }
    // module
    {
        String module = getFileContentSrc("test/Module.gwt.xml");
        assertTrue(module.contains("com.google.gwt.i18n.I18N"));
    }
    // refresh, check that CONSTANTS is used and setTitle() executed
    {
        frame.refresh();
        assertEquals("My title", ReflectionUtils.invokeMethod(frame.getObject(), "getTitle()"));
    }
    // execute scheduled actions
    waitEventLoop(0);
}

From source file:com.gwtplatform.plugin.wizard.NewProjectWizard.java

License:Apache License

@SuppressWarnings({ "rawtypes", "unchecked" })
protected boolean finish(IProgressMonitor desiredMonitor) {
    IProgressMonitor monitor = desiredMonitor;
    if (monitor == null) {
        monitor = new NullProgressMonitor();
    }// w  ww . j a  va  2  s . com

    try {
        if (GWTPreferences.getDefaultRuntime().getVersion().isEmpty()) {
            IStatus status = new Status(IStatus.ERROR, Activator.PLUGIN_ID, "No default GWT SDK.");

            ErrorDialog.openError(getShell(), null, null, status);

            return false;
        }

        monitor.beginTask("GWT-Platform project creation", 4);

        // Project base creation
        monitor.subTask("Base project creation");
        formattedName = projectNameToClassName(page.getProjectName(), page.isRemoveEnabled());
        IProject project = ResourcesPlugin.getWorkspace().getRoot().getProject(page.getProjectName());

        // Project location
        URI location = null;
        String workspace = ResourcesPlugin.getWorkspace().getRoot().getLocationURI().toString() + "/";
        if (page.getProjectLocation() != null && !workspace.equals(page.getProjectLocation().toString())) {
            location = page.getProjectLocation();
        }
        IProjectDescription description = project.getWorkspace().newProjectDescription(project.getName());
        description.setLocationURI(location);

        // Project natures and builders
        ICommand javaBuilder = description.newCommand();
        javaBuilder.setBuilderName(JavaCore.BUILDER_ID);

        ICommand webAppBuilder = description.newCommand();
        webAppBuilder.setBuilderName(WebAppProjectValidator.BUILDER_ID);

        ICommand gwtBuilder = description.newCommand();
        // TODO use the BUILDER_UI field
        gwtBuilder.setBuilderName("com.google.gwt.eclipse.core.gwtProjectValidator");

        if (page.useGAE()) {
            ICommand gaeBuilder = description.newCommand();
            gaeBuilder.setBuilderName(GaeProjectValidator.BUILDER_ID);

            // TODO use the BUILDER_UI field
            ICommand enhancer = description.newCommand();
            // TODO use the BUILDER_UI field
            enhancer.setBuilderName("com.google.appengine.eclipse.core.enhancerbuilder");

            description.setBuildSpec(
                    new ICommand[] { javaBuilder, webAppBuilder, gwtBuilder, gaeBuilder, enhancer });
            description.setNatureIds(
                    new String[] { JavaCore.NATURE_ID, GWTNature.NATURE_ID, GaeNature.NATURE_ID });
        } else {
            description.setBuildSpec(new ICommand[] { javaBuilder, webAppBuilder, gwtBuilder });
            description.setNatureIds(new String[] { JavaCore.NATURE_ID, GWTNature.NATURE_ID });
        }

        project.create(description, monitor);
        if (!project.isOpen()) {
            project.open(monitor);
        }
        monitor.worked(1);

        // Java Project creation
        monitor.subTask("Classpath entries creation");
        IJavaProject javaProject = JavaCore.create(project);

        // war/WEB-INF/lib folder creation
        IPath warPath = new Path("war");
        project.getFolder(warPath).create(false, true, monitor);

        IPath webInfPath = warPath.append("WEB-INF");
        project.getFolder(webInfPath).create(false, true, monitor);

        IPath libPath = webInfPath.append("lib");
        project.getFolder(libPath).create(false, true, monitor);

        Thread.sleep(1000);

        Jar[] libs = VersionTool.getLibs(project, libPath);

        // Classpath Entries creation
        List<IClasspathEntry> entries = new ArrayList<IClasspathEntry>();

        // Default output location
        IPath outputPath = new Path("/" + page.getProjectName()).append(webInfPath).append("classes");
        javaProject.setOutputLocation(outputPath, monitor);

        // Source folder
        IPath srcPath = new Path("src");
        project.getFolder(srcPath).create(false, true, monitor);

        entries.add(JavaCore.newSourceEntry(javaProject.getPath().append("src")));

        // GWT SDK container
        IPath gwtContainer = GWTRuntimeContainer.CONTAINER_PATH;
        ClasspathContainerInitializer gwtInitializer = JavaCore
                .getClasspathContainerInitializer(gwtContainer.segment(0));
        gwtInitializer.initialize(gwtContainer, javaProject);
        entries.add(JavaCore.newContainerEntry(gwtContainer));

        // GAE SDK container
        if (page.useGAE()) {
            IPath gaeContainer = GaeSdkContainer.CONTAINER_PATH;
            ClasspathContainerInitializer gaeInitializer = JavaCore
                    .getClasspathContainerInitializer(gaeContainer.segment(0));
            gaeInitializer.initialize(gaeContainer, javaProject);
            entries.add(JavaCore.newContainerEntry(gaeContainer));
        }

        // JRE container
        entries.addAll(Arrays.asList(PreferenceConstants.getDefaultJRELibrary()));

        // GWTP libs
        for (Jar lib : libs) {
            entries.add(JavaCore.newLibraryEntry(lib.getFile().getFullPath(), null, null));
        }

        javaProject.setRawClasspath(entries.toArray(new IClasspathEntry[entries.size()]), monitor);
        monitor.worked(1);

        monitor.subTask("Default classes creation");
        IPackageFragmentRoot root = javaProject.findPackageFragmentRoot(javaProject.getPath().append("src"));

        // Create sources
        if (page.useGAE()) {
            Log4j log4j = new Log4j(project, srcPath);
            log4j.createFile();

            IPath metaInfPath = srcPath.append("META-INF");
            project.getFolder(metaInfPath).create(false, true, monitor);

            Jdoconfig jdoconfig = new Jdoconfig(project, metaInfPath);
            jdoconfig.createFile();
        }

        IPackageFragment projectPackage = root.createPackageFragment(page.getProjectPackage(), false, monitor);

        // Client package
        IPackageFragment clientPackage = root.createPackageFragment(projectPackage.getElementName() + ".client",
                false, monitor);

        // Place package
        IPackageFragment placePackage = root.createPackageFragment(clientPackage.getElementName() + ".place",
                false, monitor);

        PlaceAnnotation defaultPlace = new PlaceAnnotation(root, placePackage.getElementName(), "DefaultPlace",
                sourceWriterFactory);

        PlaceManager placeManager = new PlaceManager(root, placePackage.getElementName(), "ClientPlaceManager",
                sourceWriterFactory);
        IField defaultPlaceField = placeManager.createPlaceRequestField(defaultPlace.getType());
        placeManager.createConstructor(new IType[] { defaultPlace.getType() },
                new IField[] { defaultPlaceField });
        placeManager.createRevealDefaultPlaceMethod(defaultPlaceField);

        Tokens tokens = new Tokens(root, placePackage.getElementName(), "NameTokens", sourceWriterFactory);

        // Gin package
        IPackageFragment ginPackage = root.createPackageFragment(clientPackage.getElementName() + ".gin", false,
                monitor);

        PresenterModule presenterModule = new PresenterModule(root, ginPackage.getElementName(), "ClientModule",
                sourceWriterFactory);
        presenterModule.createConfigureMethod(placeManager.getType());

        Ginjector ginjector = new Ginjector(root, ginPackage.getElementName(), "ClientGinjector",
                presenterModule.getType(), sourceWriterFactory);
        ginjector.createDefaultGetterMethods();

        // Client package contents
        EntryPoint entryPoint = new EntryPoint(root, clientPackage.getElementName(), formattedName,
                sourceWriterFactory);
        entryPoint.createGinjectorField(ginjector.getType());
        entryPoint.createOnModuleLoadMethod();

        // Project package contents
        GwtXmlModule gwtXmlModule = new GwtXmlModule(root, projectPackage.getElementName(), formattedName);
        gwtXmlModule.createFile(entryPoint.getType(), ginjector.getType());

        // Server package
        IPackageFragment serverPackage = root.createPackageFragment(projectPackage.getElementName() + ".server",
                false, monitor);

        // Guice package
        IPackageFragment guicePackage = root.createPackageFragment(serverPackage.getElementName() + ".guice",
                false, monitor);

        String gwtVersion = GWTPreferences.getDefaultRuntime().getVersion();

        ServletModule servletModule = new ServletModule(root, guicePackage.getElementName(),
                "DispatchServletModule", sourceWriterFactory);
        servletModule.createConfigureServletsMethod(gwtVersion);

        GuiceHandlerModule handlerModule = new GuiceHandlerModule(root, guicePackage.getElementName(),
                "ServerModule", sourceWriterFactory);
        handlerModule.createConfigureHandlersMethod();

        GuiceServletContextListener guiceServletContextListener = new GuiceServletContextListener(root,
                guicePackage.getElementName(), "GuiceServletConfig", sourceWriterFactory);
        guiceServletContextListener.createInjectorGetterMethod(handlerModule.getType(),
                servletModule.getType());

        // Shared package
        root.createPackageFragment(projectPackage.getElementName() + ".shared", false, monitor);

        // Basic sample creation
        if (page.isSample()) {
            BasicSampleBuilder sampleBuilder = new BasicSampleBuilder(root, projectPackage,
                    sourceWriterFactory);
            sampleBuilder.createSample(ginjector, presenterModule, tokens, defaultPlace, handlerModule);
        }

        // Commit
        presenterModule.commit();
        ginjector.commit();
        defaultPlace.commit();
        placeManager.commit();
        tokens.commit();
        entryPoint.commit();

        servletModule.commit();
        handlerModule.commit();
        guiceServletContextListener.commit();

        // war contents
        ProjectHTML projectHTML = new ProjectHTML(project, warPath, project.getName());
        projectHTML.createFile();

        ProjectCSS projectCSS = new ProjectCSS(project, warPath, project.getName());
        projectCSS.createFile();

        // war/WEB-INF contents
        WebXml webXml = new WebXml(project, webInfPath);
        webXml.createFile(projectHTML.getFile(), guiceServletContextListener.getType());

        if (page.useGAE()) {
            AppengineWebXml appengineWebXml = new AppengineWebXml(project, webInfPath);
            appengineWebXml.createFile();

            Logging logging = new Logging(project, webInfPath);
            logging.createFile();
        }
        monitor.worked(1);

        // Launch Config
        monitor.subTask("Launch config creation");

        ILaunchConfigurationWorkingCopy launchConfig = WebAppLaunchUtil.createLaunchConfigWorkingCopy(
                project.getName(), project, WebAppLaunchUtil.determineStartupURL(project, false), false);
        ILaunchGroup[] groups = DebugUITools.getLaunchGroups();

        ArrayList groupsNames = new ArrayList();
        for (ILaunchGroup group : groups) {
            if ((!("org.eclipse.debug.ui.launchGroup.debug".equals(group.getIdentifier())))
                    && (!("org.eclipse.debug.ui.launchGroup.run".equals(group.getIdentifier())))) {
                continue;
            }
            groupsNames.add(group.getIdentifier());
        }

        launchConfig.setAttribute("org.eclipse.debug.ui.favoriteGroups", groupsNames);
        launchConfig.doSave();

        project.getProject().setPersistentProperty(new QualifiedName(Activator.PLUGIN_ID, "nametokens"),
                tokens.getType().getFullyQualifiedName());
        project.getProject().setPersistentProperty(new QualifiedName(Activator.PLUGIN_ID, "ginjector"),
                ginjector.getType().getFullyQualifiedName());
        project.getProject().setPersistentProperty(new QualifiedName(Activator.PLUGIN_ID, "presentermodule"),
                presenterModule.getType().getFullyQualifiedName());
        project.getProject().setPersistentProperty(new QualifiedName(Activator.PLUGIN_ID, "handlermodule"),
                handlerModule.getType().getFullyQualifiedName());
        project.getProject().setPersistentProperty(new QualifiedName(Activator.PLUGIN_ID, "action"),
                "com.gwtplatform.dispatch.shared.ActionImpl");

        // Remove bin folder
        IFolder binFolder = project.getFolder(new Path("/bin"));
        if (binFolder.exists()) {
            binFolder.delete(true, monitor);
        }

        monitor.worked(1);
    } catch (Exception e) {
        IStatus status = new Status(IStatus.ERROR, Activator.PLUGIN_ID,
                "An unexpected error has happened. Close the wizard and retry.", e);

        ErrorDialog.openError(getShell(), null, null, status);

        return false;
    }

    monitor.done();
    return true;
}