Example usage for org.eclipse.jdt.core JavaCore newSourceEntry

List of usage examples for org.eclipse.jdt.core JavaCore newSourceEntry

  1. HOME
  2. Java
  3. org.eclipse.jdt
  4. org.eclipse.jdt.core.*
  5. JavaCore
  6. newSourceEntry

Introduction

In this page you can find the example usage for org.eclipse.jdt.core JavaCore newSourceEntry.

Prototype

public static IClasspathEntry newSourceEntry(IPath path)

Source Link

Document

Creates and returns a new classpath entry of kind CPE_SOURCE for all files in the project's source folder identified by the given absolute workspace-relative path.

Usage

From source file:ar.com.comunidadesfera.observatorio.jdt.PaginaAsistenteCrearProyectoJava.java

License:Open Source License

@Override
public IClasspathEntry[] getSourceClasspathEntries() {

    IPath sourceFolderPath = new Path(getProjectName()).makeAbsolute();

    /* Fuerza la localizacin de los fuentes en la raz del proyecto */
    return new IClasspathEntry[] { JavaCore.newSourceEntry(sourceFolderPath) };
}

From source file:ariba.ideplugin.eclipse.wizards.CreateProject.java

License:Apache License

public void updateClasspath(IJavaProject proj, File root, String projectName, IProgressMonitor monitor) {
    try {//from ww w .  j  a va  2s .c  o m
        File buildFile = new File(root, "build.xml");
        List<String> paths = _connector.getRequiredLibs(buildFile);

        IClasspathEntry jreEntry = JavaCore
                .newContainerEntry(new Path("org.eclipse.jdt.launching.JRE_CONTAINER"));
        IClasspathEntry srcEntry = JavaCore.newSourceEntry(new Path("/" + projectName));
        ArrayList<IClasspathEntry> entries = new ArrayList<IClasspathEntry>();
        entries.add(srcEntry);
        entries.add(jreEntry);

        String awhome = new File(_connector.getAWHome()).getCanonicalPath();
        String fileSeperator = System.getProperty("file.separator");
        int len = awhome.endsWith(fileSeperator) ? awhome.length() - 1 : awhome.length();

        for (int i = 0; i < paths.size(); i++) {
            String path = new File(paths.get(i)).getCanonicalPath();

            if (path.startsWith(awhome)) {
                path = Activator.ClasspathAWHome + path.substring(len);
            }
            if (fileSeperator.equals("\\") && path.indexOf('\\') > -1) {
                path = path.replace('\\', '/');
            }
            if (path.endsWith(".jar") || path.endsWith(".zip")) {
                Path src = null;
                if (paths.get(i).indexOf("ariba.appcore") > -1) {
                    src = new Path(Activator.ClasspathAWHome + "/lib/ariba.appcore-src.jar");
                } else if (paths.get(i).indexOf("ariba.") > -1) {
                    src = new Path(Activator.ClasspathAWHome + "/lib/ariba.aw-all-src.jar");
                }
                if (path.startsWith(Activator.ClasspathAWHome)) {
                    entries.add(JavaCore.newVariableEntry(new Path(path), src, null));
                } else {
                    entries.add(JavaCore.newLibraryEntry(new Path(path), src, null));
                }
            }
        }
        IClasspathEntry[] centries = new IClasspathEntry[entries.size()];
        proj.setRawClasspath(entries.toArray(centries), monitor);
    } catch (JavaModelException e) {
        throw new WrapperRuntimeException(e);
    } catch (IOException e) {
        throw new WrapperRuntimeException(e);
    }
}

From source file:at.bestsolution.efxclipse.tooling.rrobot.impl.JDTProjectHandler.java

License:Open Source License

protected IStatus customizeProject(IProgressMonitor monitor, IProject project, P model) {
    try {// w ww.j ava 2s.c om
        addNatureToProject(project, JavaCore.NATURE_ID, monitor);

        IJavaProject javaProject = JavaCore.create(project);

        javaProject.setOutputLocation(project.getFullPath().append("bin"), monitor); //FIXME has to come from model
        IClasspathEntry[] tmpEntries = createClasspathEntries(model);
        IClasspathEntry[] entries = new IClasspathEntry[tmpEntries.length + model.getSourceFragments().size()];
        int i = 0;
        for (SourceFragment f : model.getSourceFragments()) {
            StringBuilder b = new StringBuilder();
            Folder folder = f.getFolder();
            while (folder != null) {
                if (b.length() > 0) {
                    b.insert(0, "/");
                }
                b.insert(0, folder.getName());
                if (folder.eContainer() instanceof Folder) {
                    folder = (Folder) folder.eContainer();
                } else {
                    break;
                }
            }

            entries[i] = JavaCore.newSourceEntry(project.getProject().getFullPath().append(b.toString()));
        }

        System.arraycopy(tmpEntries, 0, entries, model.getSourceFragments().size(), tmpEntries.length);
        javaProject.setRawClasspath(entries, monitor);

    } catch (CoreException e) {
        return new Status(IStatus.ERROR, PLUGIN_ID, "Unable to add nature", e);
    }
    return super.customizeProject(monitor, project, model);
}

From source file:at.bestsolution.fxide.jdt.services.JDTModuleTypeService.java

License:Open Source License

@Override
public Status createModule(IProject project, IResource resource) {
    IProjectDescription description = project.getWorkspace().newProjectDescription(project.getName());
    description.setNatureIds(new String[] { JavaCore.NATURE_ID });
    ICommand cmd = description.newCommand();
    cmd.setBuilderName(JavaCore.BUILDER_ID);
    description.setBuildSpec(new ICommand[] { cmd });

    try {/*from w  w w . j a va2  s  .  c  om*/
        project.create(description, null);
        project.open(null);

        project.getFolder(new Path("target")).create(true, true, null);
        project.getFolder(new Path("target").append("classes")).create(true, true, null);

        project.getFolder(new Path("target")).setDerived(true, null);
        project.getFolder(new Path("target").append("classes")).setDerived(true, null);

        project.getFolder(new Path("src")).create(true, true, null);

        project.getFolder(new Path("src").append("main")).create(true, true, null);
        project.getFolder(new Path("src").append("main").append("java")).create(true, true, null);
        project.getFolder(new Path("src").append("main").append("resources")).create(true, true, null);

        project.getFolder(new Path("src").append("test")).create(true, true, null);
        project.getFolder(new Path("src").append("test").append("java")).create(true, true, null);
        project.getFolder(new Path("src").append("test").append("resources")).create(true, true, null);

        //         IExecutionEnvironmentsManager executionEnvironmentsManager = JavaRuntime.getExecutionEnvironmentsManager();
        //         IExecutionEnvironment[] executionEnvironments = executionEnvironmentsManager.getExecutionEnvironments();
        //         System.err.println(JavaRuntime.getDefaultVMInstall().getInstallLocation());

        IJavaProject jProject = JavaCore.create(project);
        jProject.setOutputLocation(project.getFolder(new Path("target").append("classes")).getFullPath(), null);

        List<IClasspathEntry> entries = new ArrayList<>();
        entries.add(JavaCore.newSourceEntry(
                project.getProject().getFullPath().append("src").append("main").append("java")));
        entries.add(JavaCore.newSourceEntry(
                project.getProject().getFullPath().append("src").append("main").append("resources")));
        entries.add(JavaCore.newSourceEntry(
                project.getProject().getFullPath().append("src").append("test").append("java")));
        entries.add(JavaCore.newSourceEntry(
                project.getProject().getFullPath().append("src").append("test").append("resources")));
        entries.add(JavaCore.newContainerEntry(JavaRuntime.newDefaultJREContainerPath()));

        jProject.setRawClasspath(entries.toArray(new IClasspathEntry[0]), null);
        project.getWorkspace().save(true, null);
        return Status.ok();
    } catch (CoreException ex) {
        return Status.status(State.ERROR, -1, "Failed to create project", ex);
    }
}

From source file:at.component.newcomponentwizard.generator.NewProjectCreationOperation.java

License:Open Source License

protected IClasspathEntry[] getInternalClassPathEntries(IJavaProject project, IFieldData data) {
    if (data.getSourceFolderName() == null) {
        return new IClasspathEntry[0];
    }//from w w  w.j ava  2s.  co m
    IClasspathEntry[] entries = new IClasspathEntry[1];
    IPath path = project.getProject().getFullPath().append(data.getSourceFolderName());
    entries[0] = JavaCore.newSourceEntry(path);
    return entries;
}

From source file:at.spardat.xma.gui.projectw.cp.ProjectClassPathHandler.java

License:Open Source License

public static IClasspathEntry[] createClassPath(ClassPathDetector detec, IJavaProject prj, String prjName) {

    List cp = new ArrayList();
    try {/*from www.j  a v  a  2 s .  c o m*/
        if (detec != null) {
            IClasspathEntry[] entries = detec.getClasspath();
            if (entries != null)
                cp.addAll(Arrays.asList(entries));
        }

        //          IClasspathEntry[] defaultEntries =  prj.getRawClasspath();
        //          if( defaultEntries != null)
        //          cp.addAll(Arrays.asList(defaultEntries));

        Path p = null;
        IClasspathEntry entry = null;

        //compute the basic classpath
        IClassPathProvider prov = new BasicClassPathProvider();
        cp.addAll(Arrays.asList(prov.provideCP()));

        //compute the additive classpath from the extension
        prov = XMAProjectCreationWizzardPlugin.getDefault().getClassPathProvider();
        cp.addAll(Arrays.asList(prov.provideCP()));

        p = new Path(JavaRuntime.JRE_CONTAINER);
        entry = JavaCore.newContainerEntry(p);
        cp.add(entry);

        p = new Path("/" + prjName + "/src");
        entry = JavaCore.newSourceEntry(p);
        cp.add(entry);
        return (IClasspathEntry[]) cp.toArray(new IClasspathEntry[cp.size()]);
    } catch (Exception e) {
        IStatus status = new Status(IStatus.ERROR, XMAProjectCreationWizzardPlugin.PLUGINID, -1,
                "Error creating the classpath", e);
        XMAProjectCreationWizzardPlugin.getDefault().getLog().log(status);
        return null;
    }
}

From source file:ca.mcgill.sable.soot.launching.DavaHandler.java

License:Open Source License

private boolean createSpecialDavaProject(IPath jreLibPath) {
    IWorkbenchWindow window = SootPlugin.getDefault().getWorkbench().getActiveWorkbenchWindow();
    MessageDialog create = new MessageDialog(window.getShell(), Messages.getString("DavaHandler.Soot_Question"),
            null,//from w w  w  .j  ava  2 s .  com
            Messages.getString(
                    "DavaHandler.Would_you_like_to_create_a_new_Dava_Project_with_generated_Dava_src_files"),
            0, new String[] { Messages.getString("DavaHandler.OK"), Messages.getString("DavaHandler.Cancel") },
            0);
    create.open();
    if (create.getReturnCode() == Dialog.OK) {
        // create proj
        IProject proj = SootPlugin.getWorkspace().getRoot().getProject(getDavaProjName());
        if (!proj.exists()) {
            try {
                proj.create(null);
                proj.open(null);
                IProjectDescription pd = proj.getDescription();
                String[] natures = new String[] { Messages.getString("org.eclipse.jdt.core.javanature") };

                pd.setNatureIds(natures);
                proj.setDescription(pd, null);

                setDavaProj(JavaCore.create(proj));
                IFolder folder = proj.getFolder(Messages.getString("DavaHandler.src")); //$NON-NLS-1$
                if (!folder.exists()) {
                    folder.create(false, true, null);
                }
                setSrcFolder(folder);
                IFolder out = proj.getFolder(Messages.getString("DavaHandler.bin")); //$NON-NLS-1$
                if (!folder.exists()) {
                    folder.create(false, true, null);
                }
                getDavaProj().setOutputLocation(out.getFullPath(), null);
                IClasspathEntry[] entries = new IClasspathEntry[2];
                entries[0] = JavaCore.newSourceEntry(folder.getFullPath());
                if (jreLibPath != null) {
                    entries[1] = JavaCore.newContainerEntry(jreLibPath);
                }
                getDavaProj().setRawClasspath(entries, null);
                return true;
            } catch (CoreException e) {
                e.printStackTrace();
                return false;
            }
        }

    }
    return false;
}

From source file:ca.ubc.cs.ferret.tests.support.TestProject.java

License:Open Source License

private IPackageFragmentRoot createSourceFolder() throws CoreException {
    IFolder folder = project.getFolder("src");
    folder.create(false, true, null);//from   www.jav a2s.co m
    IPackageFragmentRoot root = javaProject.getPackageFragmentRoot(folder);

    IClasspathEntry[] oldEntries = javaProject.getRawClasspath();
    IClasspathEntry[] newEntries = new IClasspathEntry[oldEntries.length + 1];
    System.arraycopy(oldEntries, 0, newEntries, 0, oldEntries.length);
    newEntries[oldEntries.length] = JavaCore.newSourceEntry(root.getPath());
    javaProject.setRawClasspath(newEntries, null);
    return root;
}

From source file:ccw.wizards.NewClojureProjectWizard.java

License:Open Source License

private void setupJavaProjectClassPath(IJavaProject javaProject) throws CoreException {
    IClasspathEntry[] entriesOld = javaProject.getRawClasspath();
    IClasspathEntry[] entriesNew = new IClasspathEntry[entriesOld.length + 1];

    System.arraycopy(entriesOld, 0, entriesNew, 0, entriesOld.length);

    // Ensure a proper "src" directory is used for sources (and not the project)
    for (int i = 0; i < entriesOld.length; i++) {
        if (entriesOld[i].getEntryKind() == IClasspathEntry.CPE_SOURCE) {
            IFolder src = javaProject.getProject().getFolder("src");
            if (!src.exists())
                src.create(true, true, null);
            entriesNew[i] = JavaCore.newSourceEntry(src.getFullPath());
        }//from ww w  .j ava 2s. c  o  m
    }

    entriesNew[entriesOld.length] = JavaCore
            .newContainerEntry(Path.fromPortableString(JavaRuntime.JRE_CONTAINER));

    javaProject.setRawClasspath(entriesNew, null);
    javaProject.save(null, true);
}

From source file:com.aerospike.project.wizards.NewAerospikeProjectWizard.java

License:Apache License

protected boolean generateJavaProject() {
    URL url = this.getClass().getResource("project.stg");
    final STGroup projectSTG = new STGroupFile(url.getPath());
    final String projectName = page.getProjectName();
    final String author = page.getAuthor();
    final String email = page.getEmail();
    final String artifactId = page.getArtifiactId();
    final String version = page.getVersion();
    final String packageString = page.getPackage();
    final String mainClass = page.getMainClassName();
    final String seedNode = page.getSeedNode();
    final String port = page.getPortString();
    final boolean generateMain = page.getGenerateMain();
    final boolean generateJUnit = page.getGenerateJUnit();
    IRunnableWithProgress op = new IRunnableWithProgress() {
        public void run(IProgressMonitor monitor) throws InvocationTargetException {
            try {
                //Create the project
                IProject project = createProject(projectName, monitor);
                project.setPersistentProperty(CoreActivator.SEED_NODE_PROPERTY, seedNode);
                project.setPersistentProperty(CoreActivator.PORT_PROPERTY, port);
                project.setPersistentProperty(CoreActivator.UDF_DIRECTORY, null);
                project.setPersistentProperty(CoreActivator.AQL_GENERATION_DIRECTORY, null);
                //make a java project
                IJavaProject javaProject = JavaCore.create(project);
                // create the classpath entries
                List<IClasspathEntry> entries = new ArrayList<IClasspathEntry>();
                IExecutionEnvironmentsManager executionEnvironmentsManager = JavaRuntime
                        .getExecutionEnvironmentsManager();
                IExecutionEnvironment[] executionEnvironments = executionEnvironmentsManager
                        .getExecutionEnvironments();
                for (IExecutionEnvironment iExecutionEnvironment : executionEnvironments) {
                    // We will look for JavaSE-1.6 as the JRE container to add to our classpath
                    if ("JavaSE-1.6".equals(iExecutionEnvironment.getId())) {
                        entries.add(JavaCore
                                .newContainerEntry(JavaRuntime.newJREContainerPath(iExecutionEnvironment)));
                        break;
                    } else if ("JavaSE-1.5".equals(iExecutionEnvironment.getId())) {
                        entries.add(JavaCore
                                .newContainerEntry(JavaRuntime.newJREContainerPath(iExecutionEnvironment)));
                        break;
                    }/*from   www  .  ja  v  a  2s  . c o  m*/
                }
                IClasspathEntry mavenEntry = JavaCore.newContainerEntry(
                        new Path("org.eclipse.m2e.MAVEN2_CLASSPATH_CONTAINER"), new IAccessRule[0],
                        new IClasspathAttribute[] { JavaCore.newClasspathAttribute(
                                "org.eclipse.jst.component.dependency", "/WEB-INF/lib") },
                        false);
                entries.add(mavenEntry);
                javaProject.setRawClasspath(entries.toArray(new IClasspathEntry[entries.size()]), null);
                // create source folders
                IFolder srcMainJava = project.getFolder("src/main/java");
                createFolder(srcMainJava);
                IFolder srcMainResource = project.getFolder("src/main/resource");
                createFolder(srcMainResource);
                IFolder srcTestJava = project.getFolder("src/test/java");
                createFolder(srcTestJava);
                IFolder srcTestResource = project.getFolder("src/test/resource");
                createFolder(srcTestResource);
                // create aerospike folders
                IFolder srcUDF = project.getFolder(store.getString(PreferenceConstants.UDF_PATH));
                createFolder(srcUDF);
                IFolder srcGenerated = project.getFolder(store.getString(PreferenceConstants.GENERATION_PATH));
                createFolder(srcGenerated);
                IFolder srcAql = project.getFolder("aql");
                createFolder(srcAql);
                //
                IPackageFragmentRoot mainJava = javaProject.getPackageFragmentRoot(srcMainJava);
                IPackageFragmentRoot mainResource = javaProject.getPackageFragmentRoot(srcMainResource);
                IPackageFragmentRoot testJava = javaProject.getPackageFragmentRoot(srcTestJava);
                IPackageFragmentRoot testResource = javaProject.getPackageFragmentRoot(srcTestResource);
                IPackageFragmentRoot mainGenerated = javaProject.getPackageFragmentRoot(srcGenerated);
                IClasspathEntry[] oldEntries = javaProject.getRawClasspath();
                IClasspathEntry[] newEntries = new IClasspathEntry[oldEntries.length + 5];
                System.arraycopy(oldEntries, 0, newEntries, 0, oldEntries.length);
                newEntries[oldEntries.length] = JavaCore.newSourceEntry(mainJava.getPath());
                newEntries[oldEntries.length + 1] = JavaCore.newSourceEntry(mainResource.getPath());
                newEntries[oldEntries.length + 2] = JavaCore.newSourceEntry(testJava.getPath());
                newEntries[oldEntries.length + 3] = JavaCore.newSourceEntry(testResource.getPath());
                newEntries[oldEntries.length + 4] = JavaCore.newSourceEntry(mainGenerated.getPath());
                javaProject.setRawClasspath(newEntries, monitor);
                // create the pom.xml
                ST template = projectSTG.getInstanceOf("pom");
                template.add("name", projectName);
                template.add("artifactId", artifactId);
                template.add("version", version);
                template.add("author", author);
                template.add("email", email);
                template.add("mainClass", mainClass);
                template.add("package", packageString);
                createFile(project, null, "pom.xml", monitor, template);
                // create the log4J.properties
                template = projectSTG.getInstanceOf("log4J");
                template.add("package", packageString);
                template.add("mainClass", mainClass);
                createFile(project, srcMainJava, "log4j.properties", monitor, template);
                // create the .gitignore
                template = projectSTG.getInstanceOf("ignore");
                createFile(project, null, ".gitignore", monitor, template);
                // create the README
                template = projectSTG.getInstanceOf("readme");
                template.add("name", projectName);
                createFile(project, null, "README.md", monitor, template);
                // create package
                // create JUnit
                if (generateJUnit) {
                    IPackageFragment pack = javaProject.getPackageFragmentRoot(srcTestJava)
                            .createPackageFragment(packageString, false, null);
                    template = projectSTG.getInstanceOf("junit");
                    template.add("name", mainClass + "Test");
                    template.add("package", packageString);
                    template.add("classUnderTest", mainClass);
                    pack.createCompilationUnit(mainClass + "Test" + ".java", template.render(), false, monitor);
                }
                // create main class
                IPackageFragment pack = javaProject.getPackageFragmentRoot(srcMainJava)
                        .createPackageFragment(packageString, false, null);
                template = projectSTG.getInstanceOf("mainClass");
                template.add("name", mainClass);
                template.add("package", packageString);
                template.add("author", author);
                template.add("seedNode", seedNode);
                template.add("port", port);
                final ICompilationUnit cu = pack.createCompilationUnit(mainClass + ".java", template.render(),
                        false, monitor);
                // open editor on main class
                monitor.setTaskName("Opening file for editing...");
                getShell().getDisplay().asyncExec(new Runnable() {
                    public void run() {
                        IWorkbenchPage page = PlatformUI.getWorkbench().getActiveWorkbenchWindow()
                                .getActivePage();
                        try {
                            IEditorPart editor = IDE.openEditor(page, (IFile) cu.getResource(), true);
                        } catch (PartInitException e) {
                        }
                    }
                });

            } catch (CoreException e) {
                throw new InvocationTargetException(e);
            } finally {
                monitor.done();
            }
        }
    };
    try {
        getContainer().run(true, false, op);
    } catch (InterruptedException e) {
        return false;
    } catch (InvocationTargetException e) {
        Throwable realException = e.getTargetException();
        MessageDialog.openError(getShell(), "Error", realException.getMessage());
        return false;
    }
    return true;
}