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.nginious.http.plugin.ProjectPropertyPage.java

License:Apache License

protected Control createContents(Composite parent) {
    initializeDialogUnits(parent);//from w  w w  .ja v  a2s  .  c om

    IAdaptable element = this.getElement();

    if (element instanceof IJavaProject) {
        IJavaProject javaProject = (IJavaProject) element;
        this.project = javaProject.getProject();
    } else {
        this.project = (IProject) element;
    }

    final Composite composite = new Composite(parent, SWT.NULL);
    composite.setFont(parent.getFont());
    composite.setLayout(initGridLayout(new GridLayout(1, false), true));
    composite.setLayoutData(new GridData(GridData.HORIZONTAL_ALIGN_FILL));

    int horizontalSpacing = convertHorizontalDLUsToPixels(IDialogConstants.HORIZONTAL_SPACING);
    int verticalSpacing = convertVerticalDLUsToPixels(IDialogConstants.VERTICAL_SPACING);
    int marginWidth = convertHorizontalDLUsToPixels(IDialogConstants.HORIZONTAL_MARGIN);
    int marginHeight = convertVerticalDLUsToPixels(IDialogConstants.VERTICAL_MARGIN);
    this.block = new PropertiesBlock(this.project, horizontalSpacing, verticalSpacing, marginWidth,
            marginHeight);
    block.createControls(composite);

    return composite;
}

From source file:com.nginious.http.plugin.ProjectPropertyPage.java

License:Apache License

private boolean setProjectProperties(int listenPort, String publishUrl, String publishUsername,
        String publishPassword, int minMemory, int maxMemory) {
    IProject project = null;//from  w  w w  .jav a 2  s  .co  m
    IAdaptable element = getElement();

    if (element instanceof IJavaProject) {
        IJavaProject javaProject = (IJavaProject) element;
        project = javaProject.getProject();
    } else {
        project = (IProject) element;
    }

    try {
        project.setPersistentProperty(NginiousPlugin.LISTEN_PORT_PROP_KEY, Integer.toString(listenPort));
        project.setPersistentProperty(NginiousPlugin.PUBLISH_URL_PROP_KEY, publishUrl);
        project.setPersistentProperty(NginiousPlugin.PUBLISH_USERNAME_PROP_KEY, publishUsername);
        project.setPersistentProperty(NginiousPlugin.PUBLISH_PASSWORD_PROP_KEY, publishPassword);
        project.setPersistentProperty(NginiousPlugin.MIN_MEMORY_PROP_KEY, Integer.toString(minMemory));
        project.setPersistentProperty(NginiousPlugin.MAX_MEMORY_PROP_KEY, Integer.toString(maxMemory));

        if (block.hasChanged()) {
            ServerManager manager = ServerManager.getInstance();
            manager.restartServer(project);
        }

        return true;
    } catch (CoreException e) {
        String title = Messages.ProjectPropertyPage_save_error_title;
        String message = Messages.ProjectPropertyPage_save_error_message;
        MessagesUtils.perform(e, getShell(), title, message);
        return false;
    }
}

From source file:com.persistent.ui.projwizard.WAProjectWizard.java

License:Open Source License

/**
 * This method returns currently selected project in workspace.
 * Do not use WAEclipseHelper Utility method instead of this method
 * @return IProject//  w  ww.j a va 2 s .c om
 */
private IProject getSelectProject() {
    IWorkbench workbench = PlatformUI.getWorkbench();
    IWorkbenchWindow window = workbench.getActiveWorkbenchWindow();
    ISelectionService service = window.getSelectionService();
    ISelection selection = service.getSelection();
    Object element = null;
    IResource resource;
    IProject selProject = null;
    if (selection instanceof IStructuredSelection) {
        IStructuredSelection structuredSel = (IStructuredSelection) selection;
        element = structuredSel.getFirstElement();
    }
    if (element instanceof IProject) {
        resource = (IResource) element;
        selProject = resource.getProject();
    } else if (element instanceof IJavaProject) {
        IJavaProject proj = ((IJavaElement) element).getJavaProject();
        selProject = proj.getProject();
    }
    return selProject;
}

From source file:com.photon.phresco.util.Utility.java

License:Apache License

private static String getEclipseHome() {
    IPath location = null;//from  ww w  .java 2 s  .  c  om
    String workingPath = "";
    ISelection selection = PlatformUI.getWorkbench().getActiveWorkbenchWindow().getActivePage().getSelection();
    if (!selection.isEmpty() && selection instanceof IStructuredSelection) {
        Object[] selectedObjects = ((IStructuredSelection) selection).toArray();
        for (Object object : selectedObjects) {
            if (object instanceof IProject) {
                IProject iProject = (IProject) object;
                location = iProject.getLocation();
            }
            if (object instanceof IJavaProject) {
                IJavaProject project = (IJavaProject) object;
                project.getJavaModel().getPath();
                location = project.getProject().getLocation();
            }
        }
        String dir = location.toOSString();
        workingPath = StringUtils.removeEnd(dir, location.lastSegment());
    } else {
        String workingDir = ResourcesPlugin.getWorkspace().getRoot().getLocation().toOSString()
                + File.separatorChar + "projects";
        File filePath = new File(workingDir);
        if (!filePath.isDirectory()) {
            filePath.mkdir();
        }
        workingPath = filePath.getPath() + File.separatorChar;
    }
    return workingPath;
}

From source file:com.redhat.ceylon.eclipse.code.explorer.JavaElementImageProvider.java

License:Open Source License

/**
 * Returns an image descriptor for a java element. This is the base image, no overlays.
 * @param element the element//from  w  w  w  .  j  ava2s.c  o m
 * @param renderFlags the image flags
 * @return returns the image descriptor
 */
public ImageDescriptor getBaseImageDescriptor(IJavaElement element, int renderFlags) {

    try {
        switch (element.getElementType()) {
        case IJavaElement.INITIALIZER:
            return JavaPluginImages.DESC_MISC_PRIVATE; // 23479
        case IJavaElement.METHOD: {
            IMethod method = (IMethod) element;
            IType declType = method.getDeclaringType();
            int flags = method.getFlags();
            if (declType.isEnum() && isDefaultFlag(flags) && method.isConstructor())
                return JavaPluginImages.DESC_MISC_PRIVATE;
            return getMethodImageDescriptor(JavaModelUtil.isInterfaceOrAnnotation(declType), flags);
        }
        case IJavaElement.FIELD: {
            IMember member = (IMember) element;
            IType declType = member.getDeclaringType();
            return getFieldImageDescriptor(JavaModelUtil.isInterfaceOrAnnotation(declType), member.getFlags());
        }
        case IJavaElement.LOCAL_VARIABLE:
            return JavaPluginImages.DESC_OBJS_LOCAL_VARIABLE;

        case IJavaElement.PACKAGE_DECLARATION:
            return JavaPluginImages.DESC_OBJS_PACKDECL;

        case IJavaElement.IMPORT_DECLARATION:
            return JavaPluginImages.DESC_OBJS_IMPDECL;

        case IJavaElement.IMPORT_CONTAINER:
            return JavaPluginImages.DESC_OBJS_IMPCONT;

        case IJavaElement.TYPE: {
            IType type = (IType) element;

            IType declType = type.getDeclaringType();
            boolean isInner = declType != null;
            boolean isInInterfaceOrAnnotation = isInner && JavaModelUtil.isInterfaceOrAnnotation(declType);
            return getTypeImageDescriptor(isInner, isInInterfaceOrAnnotation, type.getFlags(),
                    useLightIcons(renderFlags));
        }

        case IJavaElement.PACKAGE_FRAGMENT_ROOT: {
            IPackageFragmentRoot root = (IPackageFragmentRoot) element;
            IPath attach = root.getSourceAttachmentPath();
            if (root.getKind() == IPackageFragmentRoot.K_BINARY) {
                if (root.isArchive()) {
                    if (root.isExternal()) {
                        if (attach == null) {
                            return JavaPluginImages.DESC_OBJS_EXTJAR;
                        } else {
                            return JavaPluginImages.DESC_OBJS_EXTJAR_WSRC;
                        }
                    } else {
                        if (attach == null) {
                            return JavaPluginImages.DESC_OBJS_JAR;
                        } else {
                            return JavaPluginImages.DESC_OBJS_JAR_WSRC;
                        }
                    }
                } else {
                    if (attach == null) {
                        return JavaPluginImages.DESC_OBJS_CLASSFOLDER;
                    } else {
                        return JavaPluginImages.DESC_OBJS_CLASSFOLDER_WSRC;
                    }
                }
            } else {
                return JavaPluginImages.DESC_OBJS_PACKFRAG_ROOT;
            }
        }

        case IJavaElement.PACKAGE_FRAGMENT:
            return getPackageFragmentIcon(element);

        case IJavaElement.COMPILATION_UNIT:
            return JavaPluginImages.DESC_OBJS_CUNIT;

        case IJavaElement.CLASS_FILE:
            /* this is too expensive for large packages
            try {
               IClassFile cfile= (IClassFile)element;
               if (cfile.isClass())
             return JavaPluginImages.IMG_OBJS_CFILECLASS;
               return JavaPluginImages.IMG_OBJS_CFILEINT;
            } catch(JavaModelException e) {
               // fall through;
            }*/
            return JavaPluginImages.DESC_OBJS_CFILE;

        case IJavaElement.JAVA_PROJECT:
            IJavaProject jp = (IJavaProject) element;
            if (jp.getProject().isOpen()) {
                IProject project = jp.getProject();
                IWorkbenchAdapter adapter = (IWorkbenchAdapter) project.getAdapter(IWorkbenchAdapter.class);
                if (adapter != null) {
                    ImageDescriptor result = adapter.getImageDescriptor(project);
                    if (result != null)
                        return result;
                }
                return DESC_OBJ_PROJECT;
            }
            return DESC_OBJ_PROJECT_CLOSED;

        case IJavaElement.JAVA_MODEL:
            return JavaPluginImages.DESC_OBJS_JAVA_MODEL;

        case IJavaElement.TYPE_PARAMETER:
            return JavaPluginImages.DESC_OBJS_TYPEVARIABLE;

        case IJavaElement.ANNOTATION:
            return JavaPluginImages.DESC_OBJS_ANNOTATION;

        default:
            // ignore. Must be a new, yet unknown Java element
            // give an advanced IWorkbenchAdapter the chance
            IWorkbenchAdapter wbAdapter = (IWorkbenchAdapter) element.getAdapter(IWorkbenchAdapter.class);
            if (wbAdapter != null && !(wbAdapter instanceof JavaWorkbenchAdapter)) { // avoid recursion
                ImageDescriptor imageDescriptor = wbAdapter.getImageDescriptor(element);
                if (imageDescriptor != null) {
                    return imageDescriptor;
                }
            }
            return JavaPluginImages.DESC_OBJS_GHOST;
        }

    } catch (JavaModelException e) {
        if (e.isDoesNotExist())
            return JavaPluginImages.DESC_OBJS_UNKNOWN;
        JavaPlugin.log(e);
        return JavaPluginImages.DESC_OBJS_GHOST;
    }
}

From source file:com.redhat.ceylon.eclipse.code.explorer.PackageExplorerContentProvider.java

License:Open Source License

@Override
protected Object[] getPackageFragmentRoots(IJavaProject project) throws JavaModelException {
    if (!project.getProject().isOpen())
        return NO_CHILDREN;

    List<Object> result = new ArrayList<Object>();

    IPackageFragmentRoot[] roots = project.getPackageFragmentRoots();
    for (int i = 0; i < roots.length; i++) {
        IPackageFragmentRoot root = roots[i];
        IClasspathEntry classpathEntry = root.getRawClasspathEntry();
        int entryKind = classpathEntry.getEntryKind();
        if (entryKind == IClasspathEntry.CPE_CONTAINER) {
            // all ClassPathContainers are added later
        } else if (fShowLibrariesNode
                && (entryKind == IClasspathEntry.CPE_LIBRARY || entryKind == IClasspathEntry.CPE_VARIABLE)) {
            IResource resource = root.getResource();
            if (resource != null && project.getResource().equals(resource.getParent())) {
                // show resource as child of project, see https://bugs.eclipse.org/bugs/show_bug.cgi?id=141906
                result.add(resource);//  w w w .  j a v  a2  s. c  o m
            } else {
                // skip: will add the referenced library node later
            }
        } else {
            if (isProjectPackageFragmentRoot(root)) {
                // filter out package fragments that correspond to projects and
                // replace them with the package fragments directly
                Object[] fragments = getPackageFragmentRootContent(root);
                for (int j = 0; j < fragments.length; j++) {
                    result.add(fragments[j]);
                }
            } else {
                result.add(root);
            }
        }
    }

    if (fShowLibrariesNode) {
        result.add(new LibraryContainer(project));
    }

    // separate loop to make sure all containers are on the classpath (even empty ones)
    IClasspathEntry[] rawClasspath = project.getRawClasspath();
    for (int i = 0; i < rawClasspath.length; i++) {
        IClasspathEntry classpathEntry = rawClasspath[i];
        if (classpathEntry.getEntryKind() == IClasspathEntry.CPE_CONTAINER) {
            result.add(new ClassPathContainer(project, classpathEntry));
        }
    }
    Object[] resources = project.getNonJavaResources();
    for (int i = 0; i < resources.length; i++) {
        result.add(resources[i]);
    }
    return result.toArray();
}

From source file:com.redhat.ceylon.eclipse.code.explorer.PackageExplorerContentProvider.java

License:Open Source License

/**
 * Processes a delta recursively. When more than two children are affected the
 * tree is fully refreshed starting at this node.
 *
 * @param delta the delta to process//  ww  w.j  a v a2s  .  com
 * @param runnables the resulting view changes as runnables (type {@link Runnable})
 * @return true is returned if the conclusion is to refresh a parent of an element. In that case no siblings need
 * to be processed
 * @throws JavaModelException thrown when the access to an element failed
 */
private boolean processDelta(IJavaElementDelta delta, Collection<Runnable> runnables)
        throws JavaModelException {

    int kind = delta.getKind();
    int flags = delta.getFlags();
    IJavaElement element = delta.getElement();
    int elementType = element.getElementType();

    if (elementType != IJavaElement.JAVA_MODEL && elementType != IJavaElement.JAVA_PROJECT) {
        IJavaProject proj = element.getJavaProject();
        if (proj == null || !proj.getProject().isOpen()) // TODO: Not needed if parent already did the 'open' check!
            return false;
    }

    if (elementType == IJavaElement.PACKAGE_FRAGMENT) {
        if ((flags & (IJavaElementDelta.F_CONTENT
                | IJavaElementDelta.F_CHILDREN)) == IJavaElementDelta.F_CONTENT) {
            // TODO: This should never be true for folders (F_CONTENT is only for files)
            if (!fIsFlatLayout) {
                Object parent = getHierarchicalPackageParent((IPackageFragment) element);
                if (!(parent instanceof IPackageFragmentRoot)) {
                    postRefresh(internalGetParent(parent), GRANT_PARENT, element, runnables);
                    return true;
                }
            }
            // content change, without children info (for example resource added/removed to class folder package)
            postRefresh(internalGetParent(element), PARENT, element, runnables);
            return true;
        }

        if (!fIsFlatLayout) {
            if (kind == IJavaElementDelta.REMOVED) {
                final Object parent = getHierarchicalPackageParent((IPackageFragment) element);
                if (parent instanceof IPackageFragmentRoot) {
                    postRemove(element, runnables);
                    return false;
                } else {
                    postRefresh(internalGetParent(parent), GRANT_PARENT, element, runnables);
                    return true;
                }
            } else if (kind == IJavaElementDelta.ADDED) {
                final Object parent = getHierarchicalPackageParent((IPackageFragment) element);
                if (parent instanceof IPackageFragmentRoot) {
                    if (fFoldPackages) {
                        postRefresh(parent, PARENT, element, runnables);
                        return true;
                    } else {
                        postAdd(parent, element, runnables);
                        return false;
                    }
                } else {
                    postRefresh(internalGetParent(parent), GRANT_PARENT, element, runnables);
                    return true;
                }
            }
            handleAffectedChildren(delta, element, runnables);
            return false;
        }
    }

    if (elementType == IJavaElement.COMPILATION_UNIT) {
        ICompilationUnit cu = (ICompilationUnit) element;
        if (!JavaModelUtil.isPrimary(cu)) {
            return false;
        }

        if (!getProvideMembers() && cu.isWorkingCopy() && kind == IJavaElementDelta.CHANGED) {
            return false;
        }

        if (kind == IJavaElementDelta.CHANGED && !isStructuralCUChange(flags)) {
            return false; // test moved ahead
        }

        if (!isOnClassPath(cu)) { // TODO: isOnClassPath expensive! Should be put after all cheap tests
            return false;
        }

    }

    if (elementType == IJavaElement.JAVA_PROJECT) {
        // handle open and closing of a project
        if ((flags & (IJavaElementDelta.F_CLOSED | IJavaElementDelta.F_OPENED)) != 0) {
            postRefresh(element, ORIGINAL, element, runnables);
            return false;
        }
        // if the class path has changed we refresh the entire project
        if ((flags & IJavaElementDelta.F_RESOLVED_CLASSPATH_CHANGED) != 0) {
            postRefresh(element, ORIGINAL, element, runnables);
            return false;
        }
        // if added it could be that the corresponding IProject is already shown. Remove it first.
        // bug 184296
        if (kind == IJavaElementDelta.ADDED) {
            postRemove(element.getResource(), runnables);
            postAdd(element.getParent(), element, runnables);
            return false;
        }
    }

    if (kind == IJavaElementDelta.REMOVED) {
        Object parent = internalGetParent(element);
        if (element instanceof IPackageFragment) {
            // refresh package fragment root to allow filtering empty (parent) packages: bug 72923
            if (fViewer.testFindItem(parent) != null)
                postRefresh(parent, PARENT, element, runnables);
            return true;

        } else if (element instanceof IPackageFragmentRoot) {
            // libs and class folders can show up twice (in library container and as resource at original location)
            IResource resource = element.getResource();
            if (resource != null && !resource.exists())
                postRemove(resource, runnables);
        }

        postRemove(element, runnables);
        if (parent instanceof IPackageFragment)
            postUpdateIcon((IPackageFragment) parent, runnables);
        // we are filtering out empty subpackages, so we
        // a package becomes empty we remove it from the viewer.
        if (isPackageFragmentEmpty(element.getParent())) {
            if (fViewer.testFindItem(parent) != null)
                postRefresh(internalGetParent(parent), GRANT_PARENT, element, runnables);
            return true;
        }
        return false;
    }

    if (kind == IJavaElementDelta.ADDED) {
        Object parent = internalGetParent(element);
        // we are filtering out empty subpackages, so we
        // have to handle additions to them specially.
        if (parent instanceof IPackageFragment) {
            Object grandparent = internalGetParent(parent);
            // 1GE8SI6: ITPJUI:WIN98 - Rename is not shown in Packages View
            // avoid posting a refresh to an invisible parent
            if (parent.equals(fInput)) {
                postRefresh(parent, PARENT, element, runnables);
            } else {
                // refresh from grandparent if parent isn't visible yet
                if (fViewer.testFindItem(parent) == null)
                    postRefresh(grandparent, GRANT_PARENT, element, runnables);
                else {
                    postRefresh(parent, PARENT, element, runnables);
                }
            }
            return true;
        } else {
            if (element instanceof IPackageFragmentRoot
                    && ((IPackageFragmentRoot) element).getKind() != IPackageFragmentRoot.K_SOURCE) {
                // libs and class folders can show up twice (in library container or under project, and as resource at original location)
                IResource resource = element.getResource();
                if (resource != null) {
                    Object resourceParent = super.internalGetParent(resource);
                    if (resourceParent != null) {
                        IJavaProject proj = element.getJavaProject();
                        if (fShowLibrariesNode || !resourceParent.equals(proj)) {
                            postAdd(resourceParent, resource, runnables);
                        }
                    }
                }
            }
            postAdd(parent, element, runnables);
        }
    }

    if (elementType == IJavaElement.COMPILATION_UNIT || elementType == IJavaElement.CLASS_FILE) {
        if (kind == IJavaElementDelta.CHANGED) {
            // isStructuralCUChange already performed above
            postRefresh(element, ORIGINAL, element, runnables);
        }
        return false;
    }

    if (elementType == IJavaElement.PACKAGE_FRAGMENT_ROOT) {
        // the contents of an external JAR has changed
        if ((flags & IJavaElementDelta.F_ARCHIVE_CONTENT_CHANGED) != 0) {
            postRefresh(element, ORIGINAL, element, runnables);
            return false;
        }
        if ((flags & (IJavaElementDelta.F_CONTENT
                | IJavaElementDelta.F_CHILDREN)) == IJavaElementDelta.F_CONTENT) {
            // TODO: This should never be true for folders (F_CONTENT is only for files)
            // content change, without children info (for example resource added/removed to class folder package)
            postRefresh(internalGetParent(element), PARENT, element, runnables);
            return true;
        }

        // the source attachment of a JAR has changed
        if ((flags & (IJavaElementDelta.F_SOURCEATTACHED | IJavaElementDelta.F_SOURCEDETACHED)) != 0)
            postUpdateIcon(element, runnables);

        if (isClassPathChange(delta)) {
            // throw the towel and do a full refresh of the affected java project.
            postRefresh(element.getJavaProject(), PROJECT, element, runnables);
            return true;
        }
    }

    handleAffectedChildren(delta, element, runnables);
    return false;
}

From source file:com.redhat.ceylon.eclipse.code.explorer.WorkingSetAwareContentProvider.java

License:Open Source License

private IProject getProject(IJavaElement element) {
    IJavaProject project = element.getJavaProject();
    if (project == null)
        return null;
    return project.getProject();
}

From source file:com.redhat.ceylon.eclipse.code.preferences.CeylonBuildPathsBlock.java

License:Open Source License

/**
 * Initializes the classpath for the given project. Multiple calls to init are allowed,
 * but all existing settings will be cleared and replace by the given or default paths.
 * @param jproject The java project to configure. Does not have to exist.
 * @param javaOutputLocation The output location to be set in the page. If <code>null</code>
 * is passed, jdt default settings are used, or - if the project is an existing Java project- the
 * output location of the existing project
 * @param classpathEntries The classpath entries to be set in the page. If <code>null</code>
 * is passed, jdt default settings are used, or - if the project is an existing Java project - the
 * classpath entries of the existing project
 *///from w  ww .  j  a  v a  2s. c  o  m
public void init(IJavaProject jproject, IPath javaOutputLocation, IClasspathEntry[] classpathEntries,
        boolean javaCompilationEnabled) {
    fCurrJProject = jproject;
    boolean projectExists = false;
    someFoldersNeedToBeCreated = false;
    final List<CPListElement> newClassPath;
    IProject project = fCurrJProject.getProject();
    projectExists = (project.exists() && project.getFile(".classpath").exists()); //$NON-NLS-1$

    List<String> configSourceDirectories;
    List<String> configResourceDirectories;
    if (projectExists) {
        CeylonProjectConfig config = CeylonProjectConfig.get(project);
        configSourceDirectories = config.getProjectSourceDirectories();
        configResourceDirectories = config.getProjectResourceDirectories();
    } else {
        File configFile = jproject.getProject().getFile(".ceylon/config").getLocation().toFile();
        CeylonConfig ceylonConfig;
        try {
            ceylonConfig = CeylonConfigFinder.DEFAULT.loadConfigFromFile(configFile);
            configSourceDirectories = CeylonProjectConfig.getConfigSourceDirectories(ceylonConfig);
            configResourceDirectories = CeylonProjectConfig.getConfigResourceDirectories(ceylonConfig);
        } catch (IOException e) {
            configSourceDirectories = Collections.emptyList();
            configResourceDirectories = Collections.emptyList();
        }
    }

    IClasspathEntry[] existingEntries = null;
    if (projectExists) {
        if (javaOutputLocation == null) {
            javaOutputLocation = fCurrJProject.readOutputLocation();
        }
        existingEntries = fCurrJProject.readRawClasspath();
        if (classpathEntries == null) {
            classpathEntries = existingEntries;
            //TODO: read existing ceylon output location from classpathEntries
        }
    }
    if (javaOutputLocation == null) {
        javaOutputLocation = getDefaultJavaOutputLocation(jproject);
    }

    if (classpathEntries != null) {
        newClassPath = getCPListElements(classpathEntries, existingEntries);
    } else {
        newClassPath = getDefaultClassPath(jproject);
    }

    Set<String> newFolderNames = new HashSet<>();
    final List<CPListElement> newResourcePath = new ArrayList<CPListElement>();

    if (!configResourceDirectories.isEmpty()) {
        someFoldersNeedToBeCreated = resourcePathsFromStrings(fCurrJProject, configResourceDirectories,
                newFolderNames, newResourcePath);
    } else {
        IFolder defaultResourceFolder = fCurrJProject.getProject().getFolder(DEFAULT_RESOURCE_FOLDER);
        newResourcePath.add(new CPListElement(fCurrJProject, IClasspathEntry.CPE_SOURCE,
                defaultResourceFolder.getFullPath(), defaultResourceFolder));
    }

    List<CPListElement> exportedEntries = new ArrayList<CPListElement>();
    for (int i = 0; i < newClassPath.size(); i++) {
        CPListElement curr = newClassPath.get(i);
        if (curr.isExported() || curr.getEntryKind() == IClasspathEntry.CPE_SOURCE) {
            exportedEntries.add(curr);
        }
    }

    fJavaOutputLocationPath = javaOutputLocation.makeRelative();

    // inits the dialog field
    fJavaBuildPathDialogField.setText(fJavaOutputLocationPath.toString());
    fJavaBuildPathDialogField.enableButton(project.exists());
    fClassPathList.setElements(newClassPath);
    fClassPathList.setCheckedElements(exportedEntries);

    if (!projectExists) {
        IPreferenceStore store = PreferenceConstants.getPreferenceStore();
        if (!configSourceDirectories.isEmpty()
                && store.getBoolean(PreferenceConstants.SRCBIN_FOLDERS_IN_NEWPROJ)) {
            updateClassPathsFromConfigFile(configSourceDirectories, newFolderNames);
        }
    }
    fClassPathList.selectFirstElement();

    fResourcePathList.setElements(newResourcePath);
    //        fResourcePathList.setCheckedElements(exportedEntries);

    fResourcePathList.selectFirstElement();

    if (fSourceContainerPage != null) {
        fSourceContainerPage.init(fCurrJProject);
        fResourceContainerPage.init(fCurrJProject);
        fProjectsPage.init(fCurrJProject);
        //            fLibrariesPage.init(fCurrJProject);
    }

    initializeTimeStamps();
    updateUI();
}

From source file:com.redhat.ceylon.eclipse.code.preferences.CeylonBuildPathsBlock.java

License:Open Source License

public static boolean resourcePathsFromStrings(final IJavaProject javaProject,
        List<String> configResourceDirectories, Set<String> newFolderNames,
        final List<CPListElement> newResourcePath) {
    boolean someFoldersNeedToBeCreated = false;
    IProject project = javaProject.getProject();
    for (final String path : configResourceDirectories) {
        final IPath iPath = Path.fromOSString(path);
        if (!iPath.isAbsolute()) {
            IFolder folder = project.getFolder(iPath);
            newResourcePath.add(//from  w  w w  . jav  a2s .  c  om
                    new CPListElement(javaProject, IClasspathEntry.CPE_SOURCE, folder.getFullPath(), folder));
            if (!folder.exists()) {
                someFoldersNeedToBeCreated = true;
            }
        } else {
            try {
                class CPListElementHolder {
                    public CPListElement value = null;
                }
                final CPListElementHolder cpListElement = new CPListElementHolder();
                project.accept(new IResourceVisitor() {
                    @Override
                    public boolean visit(IResource resource) throws CoreException {
                        if (resource instanceof IFolder && resource.isLinked() && resource.getLocation() != null
                                && resource.getLocation().equals(iPath)) {
                            cpListElement.value = new CPListElement(null, javaProject,
                                    IClasspathEntry.CPE_SOURCE, resource.getFullPath(), resource,
                                    resource.getLocation());
                            return false;
                        }
                        return resource instanceof IFolder || resource instanceof IProject;
                    }
                });
                if (cpListElement.value == null) {
                    String newFolderName = iPath.lastSegment();
                    IFolder newFolder = project.getFolder(newFolderName);
                    int counter = 1;
                    while (newFolderNames.contains(newFolderName) || newFolder.exists()) {
                        newFolderName = iPath.lastSegment() + "_" + counter++;
                        newFolder = project.getFolder(newFolderName);
                    }
                    newFolderNames.add(newFolderName);
                    cpListElement.value = new CPListElement(null, javaProject, IClasspathEntry.CPE_SOURCE,
                            newFolder.getFullPath(), newFolder, iPath);
                    someFoldersNeedToBeCreated = true;
                }
                newResourcePath.add(cpListElement.value);
            } catch (CoreException e) {
                e.printStackTrace();
            }
        }
    }
    return someFoldersNeedToBeCreated;
}