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

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

  1. HOME
  2. Java
  3. org.eclipse.jdt
  4. org.eclipse.jdt.core.*
  5. IJavaProject
  6. getProject

Introduction

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

Prototype

IProject getProject();

Source Link

Document

Returns the IProject on which this IJavaProject was created.

Usage

From source file:com.google.gdt.eclipse.designer.util.resources.DefaultResourcesProvider.java

License:Open Source License

/**
 * @return the {@link File}'s for each jar/directory entry of classpath for {@link IJavaProject}
 *         that contains given GWT module.
 *//* www.j av  a2 s . co  m*/
private static List<File> getFiles(IJavaProject javaProject) throws Exception {
    List<File> files = Lists.newArrayList();
    // prepare source/classpath entries
    List<String> entries;
    {
        entries = Lists.newArrayList();
        addSourceFolders(Sets.<IProject>newHashSet(), entries, javaProject.getProject());
        {
            String[] classpathEntries = ProjectClassLoader.getClasspath(javaProject);
            for (String classpathEntry : classpathEntries) {
                if (classpathEntry.endsWith(".jar")) {
                    entries.add(classpathEntry);
                }
            }
        }
    }
    // create File for each entry
    for (String entry : entries) {
        // not very good optimization, but it should be done - filter out JRE jar's
        if (entry.indexOf("/jre/") != -1) {
            continue;
        }
        // OK, add File
        files.add(new File(entry));
    }
    return files;
}

From source file:com.google.gdt.eclipse.designer.util.Utils.java

License:Open Source License

/**
 * @return the GWT Java projects.//from  w w  w .j a va  2 s . c  o  m
 */
public static List<IJavaProject> getGWTProjects() throws CoreException {
    List<IJavaProject> gwtProjects = Lists.newArrayList();
    for (IJavaProject javaProject : getJavaModel().getJavaProjects()) {
        if (isGWTProject(javaProject.getProject())) {
            gwtProjects.add(javaProject);
        }
    }
    return gwtProjects;
}

From source file:com.google.gdt.eclipse.designer.wizards.model.module.CreateModuleOperation.java

License:Open Source License

public IFile create(ModuleConfiguration configuration) throws Exception {
    String moduleName = configuration.getModuleName();
    String packageName = configuration.getPackageName();
    // create packages
    IPackageFragment packageFragment = getPackage(root, packageName);
    getPackage(root, packageName + ".client");
    getPackage(root, packageName + ".server");
    // /*from w  w  w  .  j a v a 2  s .c  o m*/
    // create folders
    IJavaProject javaProject = packageFragment.getJavaProject();
    IProject project = javaProject.getProject();
    String webFolderName = WebUtils.getWebFolderName(project);
    IFolder webFolder = project.getFolder(webFolderName);
    IFolder webInfFolder = project.getFolder(webFolderName + "/WEB-INF");
    // create module
    IFile file;
    if (configuration.isCreateEntryPoint()) {
        // prepare variables
        Map<String, String> variables = configuration.getVariables();
        variables.put("packageName", packageName);
        variables.put("className", moduleName);
        // prepare 'bootstrap' variable
        String bootstrapPrefix = packageName + "." + moduleName;
        variables.put("bootstrap", bootstrapPrefix + "/" + bootstrapPrefix + ".nocache.js");
        // create module
        file = createFileFromTemplate(packageFragment, moduleName + ".gwt.xml", "Module.gwt.xml", variables);
        // create EntryPoint
        CreateEntryPointOperation entryPointOperation = new CreateEntryPointOperation(root);
        entryPointOperation.create(configuration.getEntryPointConfiguration());
        // create files from templates
        createFileFromTemplate(webFolder, moduleName + ".html", "Module.html", variables);
        createFileFromTemplate(webFolder, moduleName + ".css", "Module.css", variables);
        copyTemplateFiles(webFolder, "images");
        // configure web.xml
        if (!webInfFolder.getFile("web.xml").exists()) {
            variables.put("welcome-file-name", moduleName);
            createFileFromTemplate(webInfFolder, "web.xml", "web.xml", variables);
        }
        // open entry point in editor
        {
            String qualifiedEntryPoint = packageName + ".client." + moduleName;
            IType type = WorkspaceUtils.waitForType(root.getJavaProject(), qualifiedEntryPoint);
            IDE.openEditor(DesignerPlugin.getActivePage(), (IFile) type.getUnderlyingResource(),
                    IDesignerEditor.ID);
        }
    } else {
        // create empty module
        file = createFile(packageFragment, moduleName + ".gwt.xml",
                "<module>\r\n\t<inherits name=\"com.google.gwt.user.User\"/>\r\n</module>");
    }
    return file;
}

From source file:com.google.gdt.eclipse.designer.wizards.model.project.ProjectWizard.java

License:Open Source License

/**
 * Configures given {@link IJavaProject} as GWT project - adds GWT library and nature.
 *//*  w w w . ja  v  a  2s  .  com*/
public static final void configureProjectAsGWTProject(IJavaProject javaProject) throws Exception {
    IProject project = javaProject.getProject();
    // add GWT classpath
    if (!ProjectUtils.hasType(javaProject, "com.google.gwt.core.client.GWT")) {
        IClasspathEntry entry;
        if (Utils.hasGPE()) {
            entry = JavaCore.newContainerEntry(new Path("com.google.gwt.eclipse.core.GWT_CONTAINER"));
        } else {
            entry = JavaCore.newVariableEntry(new Path("GWT_HOME/gwt-user.jar"), null, null);
        }
        ProjectUtils.addClasspathEntry(javaProject, entry);
    }
    // add GWT nature
    {
        ProjectUtils.addNature(project, Constants.NATURE_ID);
        if (Utils.hasGPE()) {
            ProjectUtils.addNature(project, "com.google.gwt.eclipse.core.gwtNature");
        }
    }
    // continue
    {
        String webFolderName = WebUtils.getWebFolderName(project);
        // create folders
        ensureCreateFolder(project, webFolderName);
        ensureCreateFolder(project, webFolderName + "/WEB-INF");
        IFolder classesFolder = ensureCreateFolder(project, webFolderName + "/WEB-INF/classes");
        IFolder libFolder = ensureCreateFolder(project, webFolderName + "/WEB-INF/lib");
        // set output
        javaProject.setOutputLocation(classesFolder.getFullPath(), null);
        // copy gwt-servlet.jar
        if (!libFolder.getFile("gwt-servlet.jar").exists()) {
            String servletJarLocation = Utils.getGWTLocation(project) + "/gwt-servlet.jar";
            File srcFile = new File(servletJarLocation);
            File destFile = new File(libFolder.getLocation().toFile(), "gwt-servlet.jar");
            FileUtils.copyFile(srcFile, destFile);
            libFolder.refreshLocal(IResource.DEPTH_INFINITE, null);
        }
    }
}

From source file:com.google.gdt.eclipse.designer.wizards.ui.JUnitWizardPage.java

License:Open Source License

private IPackageFragmentRoot handleTestSourceFolder(IJavaProject javaProject) throws Exception {
    String testSourceFolderName = com.google.gdt.eclipse.designer.Activator.getStore()
            .getString(Constants.P_GWT_TESTS_SOURCE_FOLDER);
    IFolder testSourceFolder = javaProject.getProject().getFolder(testSourceFolderName);
    IPackageFragmentRoot testSourceFragmentRoot = (IPackageFragmentRoot) JavaCore.create(testSourceFolder);
    // check create
    if (!testSourceFolder.exists() || testSourceFragmentRoot == null || !testSourceFragmentRoot.exists()) {
        // create folder
        if (!testSourceFolder.exists()) {
            testSourceFolder.create(true, false, null);
        }/*from  w  ww .j a  v  a2  s  . c  o m*/
        IClasspathEntry[] classpath = javaProject.getRawClasspath();
        // find last source entry
        int insertIndex = -1;
        for (int i = 0; i < classpath.length; i++) {
            if (classpath[i].getEntryKind() == IClasspathEntry.CPE_SOURCE) {
                insertIndex = i + 1;
            }
        }
        // insert new source to entries
        IClasspathEntry testSourceEntry = JavaCore.newSourceEntry(testSourceFolder.getFullPath());
        if (insertIndex == -1) {
            classpath = (IClasspathEntry[]) ArrayUtils.add(classpath, testSourceEntry);
        } else {
            classpath = (IClasspathEntry[]) ArrayUtils.add(classpath, insertIndex, testSourceEntry);
        }
        // modify classpath
        javaProject.setRawClasspath(classpath, javaProject.getOutputLocation(), null);
        testSourceFragmentRoot = (IPackageFragmentRoot) JavaCore.create(testSourceFolder);
    }
    //
    setPackageFragmentRoot(testSourceFragmentRoot, true);
    return testSourceFragmentRoot;
}

From source file:com.google.gdt.eclipse.managedapis.impl.ManagedApiChangeListener.java

License:Open Source License

/**
 * Implements the standard elementChanged method defined by the
 * IElementChangedListener, this method identifies events of importance to a
 * specific ManagedApiProject and calls the appropriate abstract method on a
 * match./*from   w w w .  j  a  v  a 2 s  .  co  m*/
 */
public void elementChanged(ElementChangedEvent event) {
    if (managedApiProject == null) {
        throw new IllegalStateException("managedApiProject must be set prior to registering the listener");
    }

    for (IJavaElementDelta delta : event.getDelta().getRemovedChildren()) {
        int flags = delta.getFlags();
        if (flags == 0) {
            IJavaElement element = delta.getElement();
            IJavaProject javaProject = (IJavaProject) element.getAdapter(IJavaProject.class);
            if (javaProject != null) {
                IProject project = javaProject.getProject();
                if (project.equals(managedApiProject.getJavaProject().getProject())) {
                    managedApiProjectRemoved();
                }
            }
        }
    }

    for (IJavaElementDelta delta : event.getDelta().getChangedChildren()) {
        int flags = delta.getFlags();
        if ((flags & IJavaElementDelta.F_CLASSPATH_CHANGED) != 0) {
            IJavaElement element = delta.getElement();
            if (element.getElementType() == IJavaElement.JAVA_PROJECT
                    && element.equals(managedApiProject.getJavaProject())) {
                Set<ManagedApi> managedApiRemovalSet = new HashSet<ManagedApi>(
                        delta.getChangedChildren().length);
                List<String> managedApiFolderNames = new ArrayList();
                for (IJavaElementDelta childDelta : delta.getChangedChildren()) {
                    if ((childDelta.getFlags() & IJavaElementDelta.F_REMOVED_FROM_CLASSPATH) != 0) {
                        IJavaElement childElement = childDelta.getElement();
                        if (childElement.getElementType() == IJavaElement.PACKAGE_FRAGMENT_ROOT
                                && managedApiProject.isPackageFragmentRootInManagedApi(
                                        (IPackageFragmentRoot) childElement)) {
                            String managedApiFolderName = managedApiProject
                                    .getPathRelativeToManagedApiRoot((IPackageFragmentRoot) childElement);
                            if (!managedApiFolderNames.contains(managedApiFolderName)) {
                                managedApiFolderNames.add(managedApiFolderName);
                                managedApiRemovalSet
                                        .add(managedApiProject.createManagedApi(managedApiFolderName));
                            }
                        }
                    }
                }
                if (managedApiRemovalSet.size() > 0) {
                    managedApiRemoved(
                            managedApiRemovalSet.toArray(new ManagedApiImpl[managedApiRemovalSet.size()]));
                }
            }
        } else if ((flags & IJavaElementDelta.F_CLOSED) != 0) {
            IJavaElement element = delta.getElement();
            if (element.getElementType() == IJavaElement.JAVA_PROJECT
                    && element.equals(managedApiProject.getJavaProject())) {
                managedApiProjectClosed();
            }
        }
    }
}

From source file:com.google.gdt.eclipse.managedapis.impl.ManagedApiProjectImpl.java

License:Open Source License

/**
 * Provide a simple way to produce a ManagedApiProject from a IJavaProject.
 * Note: the ManagedApiProject lives for the duration of the session even if
 * no ManagedApis are added/remaining in the project.
 * /*www.jav a  2s . co  m*/
 * @param project The source project
 * @return A ManagedApiProject wrapper
 * @throws CoreException
 */
public static ManagedApiProject getManagedApiProject(final IJavaProject project) throws CoreException {
    ManagedApiProjectImpl managedApiProject = null;
    IProject iProject = project.getProject();
    if (iProject.isOpen()) {
        managedApiProject = (ManagedApiProjectImpl) iProject
                .getSessionProperty(ManagedApiPlugin.MANAGED_API_SESSION_KEY_QNAME);
        synchronized (project) {
            if (managedApiProject == null || managedApiProject.getProject() != project.getProject()) {
                managedApiProject = new ManagedApiProjectImpl(project);
                project.getProject().setSessionProperty(ManagedApiPlugin.MANAGED_API_SESSION_KEY_QNAME,
                        managedApiProject);
                if (managedApiProject.hasManagedApis()) {
                    managedApiProject.initializeProjectWithManagedApis();
                }
            }
        }
    }
    return managedApiProject;
}

From source file:com.google.gdt.eclipse.managedapis.platform.ManagedApiContainer.java

License:Open Source License

/**
 * This method determines the ManagedApiProject that contains a given
 * ClassPathContainer./*from   w  w w .  jav  a  2s.c o m*/
 */
public static ManagedApiProject getManagedApiProjectForClassPathContainer(
        ClassPathContainer classPathContainer) {
    ManagedApiProject managedApiProject = null;
    IJavaProject javaProject = null;
    try {
        javaProject = classPathContainer.getJavaProject();
        managedApiProject = ManagedApiProjectImpl.getManagedApiProject(javaProject);
    } catch (CoreException e) {
        ManagedApiLogger.warn(e,
                MessageFormat.format("Caught core exception while trying to access ManagedApi for project {0}",
                        javaProject != null ? javaProject.getProject().getName() : "unknown"));
    }
    return managedApiProject;
}

From source file:com.google.gdt.eclipse.maven.enhancement.MavenEnhancerClasspathBuilder.java

License:Open Source License

public List<String> buildClasspath(IJavaProject javaProject) {

    try {//from  w  w w .ja v a 2s  .c  om
        if (!MavenUtils.hasMavenNature(javaProject.getProject())) {
            return null;
        }

        List<String> classpath = LaunchUtilities.getDefaultClasspath(javaProject);

        GaeSdk gaeSdk = GaeSdk.findSdkFor(javaProject);
        if (gaeSdk != null) {
            String toolsJarLocation = gaeSdk.getInstallationPath().append(GaeSdk.APPENGINE_TOOLS_API_JAR_PATH)
                    .toOSString();
            // Add this to the top of the classpath, just in case they have
            // some other version of appengine-api-tools.jar on their build
            // path (they shouldn't though).
            classpath.add(0, toolsJarLocation);
        }

        return classpath;

    } catch (CoreException ce) {
        Activator.getDefault().getLog().log(new Status(IStatus.ERROR, Activator.PLUGIN_ID,
                "Unable to generate the enhancer's classpath for project " + javaProject.getElementName(), ce));
        return null;
    }
}

From source file:com.google.gdt.eclipse.maven.launch.MavenClasspathProvider.java

License:Open Source License

@Override
public IRuntimeClasspathEntry[] computeUnresolvedClasspath(ILaunchConfiguration config) throws CoreException {
    IRuntimeClasspathEntry[] unresolvedClasspathEntries = super.computeUnresolvedClasspath(config);
    IJavaProject proj = JavaRuntime.getJavaProject(config);
    if (proj == null) {
        return unresolvedClasspathEntries;
    }/* w  w  w . ja va  2 s . c  o m*/

    /*
     * Figure out if we are supposed to be relying on the default classpath or not. The default
     * classpath is the one that is generated for a launch configuration based on the launch
     * configuration's project's build classpath.
     *
     * To determine whether or not to rely on the default classpath, we look at the
     * ATTR_DEFAULT_CLASSPATH attribute of the launch configuration. This attribute is set whenever
     * the user makes a change to the launch configuration classpath using the add/remove buttons.
     * From this point on, Eclipse will respect the user's changes and will not replace their
     * entries with the classpath that it computes.
     *
     * However, users can specify that they want to restore the behavior of having Eclipse compute
     * the classpath by clicking on the "Restore Default Entries" button. This causes the
     * ATTR_DEFAULT_ATTRIBUTE to be unset for a launch configuration.
     */
    boolean useDefault = config.getAttribute(IJavaLaunchConfigurationConstants.ATTR_DEFAULT_CLASSPATH, true);

    if (!useDefault) {
        return unresolvedClasspathEntries;
    }

    if (!MavenUtils.hasMavenNature(proj.getProject())) {
        return unresolvedClasspathEntries;
    }

    // Use a LinkedHashSet to prevent dupes
    Set<IRuntimeClasspathEntry> classpath = new LinkedHashSet<IRuntimeClasspathEntry>(
            unresolvedClasspathEntries.length);
    classpath.addAll(Arrays.asList(unresolvedClasspathEntries));

    // Add GWT dev jar
    if (GWTNature.isGWTProject(proj.getProject())) {
        addGwtDevjarIfPossible(proj, classpath);
    }

    IRuntimeClasspathEntry[] resolvedEntries = classpath.toArray(new IRuntimeClasspathEntry[classpath.size()]);

    return resolvedEntries;
}