Java 类org.eclipse.jdt.core.IJavaModel 实例源码

public ViewSiteRelationsListener(
  final IRunnableContext runnableContext,
  final IProgressService progressService,
  final ILogger logger,
  final IJavaModel model,
  final IObjectModel<IItem> selectedItemModel,
  final IObjectListModel<IItem> selectedItemsModel,
  final Label label,
  final IDependenciesModel dependenciesModel,
  final WritableList<IDependencyRelation> descriptions,
  final INameHitMaps nameHitMaps) {
  this.runnableContext = runnableContext;
  this.logger = logger;
  this.progressService = progressService;
  this.model = model;
  this.selectedItemModel = selectedItemModel;
  this.selectedItemsModel = selectedItemsModel;
  this.label = label;
  this.dependenciesModel = dependenciesModel;
  this.descriptions = descriptions;
  this.nameHitMaps = nameHitMaps;
}

public UpdateDependencyModelAction(
  final IShellProvider shellProvider,
  final Canceler canceler,
  final ILogger logger,
  final IJavaModel model,
  final IDependenciesModel dependenciesModel,
  final INameHitMaps nameHitMaps) {
  this.logger = logger;
  this.nameHitMaps = nameHitMaps;
  setToolTipText(TOOLTIP_TEXT);
  setImageDescriptor(PlatformUI.getWorkbench().getSharedImages().getImageDescriptor(ISharedImages.IMG_TOOL_FORWARD));
  this.shellProvider = shellProvider;
  this.canceler = canceler;
  this.model = model;
  this.dependenciesModel = dependenciesModel;
}

public ListRunner(
  final ICanceler canceler,
  final ILogger logger,
  final IJavaElement[] selection,
  final IDependenciesModel dependenciesModel,
  final IObjectModel<IItem> selectedItemModel,
  final IObjectListModel<IItem> selectedItemsModel,
  final Label label,
  final IJavaModel model,
  final WritableList<IDependencyRelation> relations,
  final INameHitMaps nameHitMaps) {
  this.logger = logger;
  this.selection = selection;
  this.dependenciesModel = dependenciesModel;
  this.canceler = canceler;
  this.selectedItemModel = selectedItemModel;
  this.selectedItemsModel = selectedItemsModel;
  this.label = label;
  this.model = model;
  this.relations = relations;
  this.nameHitMaps = nameHitMaps;
}

public static IJavaProject getJavaProject(String projectName) {
    IWorkspace workspace = ResourcesPlugin.getWorkspace();
    if (workspace == null) {
        System.out.println("No workspace");
        return null;
    }
    IWorkspaceRoot root = workspace.getRoot();
    if (root == null) {
        System.out.println("No workspace root");
        return null;
    }

    IJavaModel javacore = JavaCore.create(root);// this gets you the java version of the workspace
    IJavaProject project = null;
    if (javacore != null) {
        project = javacore.getJavaProject(projectName); // this returns the specified project
    }

    WorkspaceUtilities.javaProject = project;

    return project;
}

/**
 * Traverses the workspace for CompilationUnits.
 * 
 * @return the list of all CompilationUnits in the workspace
 */
public static List<ICompilationUnit> scanForCompilationUnits() {
    IWorkspace workspace = ResourcesPlugin.getWorkspace();
    if (workspace == null) {
        System.out.println("No workspace");
        return null;
    }
    IWorkspaceRoot root = workspace.getRoot();
    if (root == null) {
        System.out.println("No workspace root");
        return null;
    }

    IJavaModel javaModel = JavaCore.create(root);
    if (javaModel == null) {
        System.out.println("No Java Model in workspace");
        return null;
    }

    // Get all CompilationUnits
    return WorkspaceUtilities.collectCompilationUnits(javaModel);
}

public static IJavaProject getJavaProject(String projectName) {
    IWorkspace workspace = ResourcesPlugin.getWorkspace();
    if (workspace == null) {
        System.out.println("No workspace");
        return null;
    }
    IWorkspaceRoot root = workspace.getRoot();
    if (root == null) {
        System.out.println("No workspace root");
        return null;
    }

    IJavaModel javacore = JavaCore.create(root);// this gets you the java version of the workspace
    IJavaProject project = null;
    if (javacore != null) {
        project = javacore.getJavaProject(projectName); // this returns the specified project
    }

    WorkspaceUtilities.javaProject = project;

    return project;
}

/**
 * Traverses the workspace for CompilationUnits.
 * 
 * @return the list of all CompilationUnits in the workspace
 */
public static List<ICompilationUnit> scanForCompilationUnits() {
    IWorkspace workspace = ResourcesPlugin.getWorkspace();
    if (workspace == null) {
        System.out.println("No workspace");
        return null;
    }
    IWorkspaceRoot root = workspace.getRoot();
    if (root == null) {
        System.out.println("No workspace root");
        return null;
    }

    IJavaModel javaModel = JavaCore.create(root);
    if (javaModel == null) {
        System.out.println("No Java Model in workspace");
        return null;
    }

    // Get all CompilationUnits
    return WorkspaceUtilities.collectCompilationUnits(javaModel);
}

public static IJavaProject getJavaProject(String projectName) {
    IWorkspace workspace = ResourcesPlugin.getWorkspace();
    if (workspace == null) {
        System.out.println("No workspace");
        return null;
    }
    IWorkspaceRoot root = workspace.getRoot();
    if (root == null) {
        System.out.println("No workspace root");
        return null;
    }

    IJavaModel javacore = JavaCore.create(root);// this gets you the java version of the workspace
    IJavaProject project = null;
    if (javacore != null) {
        project = javacore.getJavaProject(projectName); // this returns the specified project
    }

    WorkspaceUtilities.javaProject = project;

    return project;
}

/**
 * Traverses the workspace for CompilationUnits.
 * 
 * @return the list of all CompilationUnits in the workspace
 */
public static List<ICompilationUnit> scanForCompilationUnits() {
    IWorkspace workspace = ResourcesPlugin.getWorkspace();
    if (workspace == null) {
        System.out.println("No workspace");
        return null;
    }
    IWorkspaceRoot root = workspace.getRoot();
    if (root == null) {
        System.out.println("No workspace root");
        return null;
    }

    IJavaModel javaModel = JavaCore.create(root);
    if (javaModel == null) {
        System.out.println("No Java Model in workspace");
        return null;
    }

    // Get all CompilationUnits
    return WorkspaceUtilities.collectCompilationUnits(javaModel);
}

private Set<IJavaElementDelta> getProjectDeltas(IJavaElementDelta delta) {
    IJavaElement element = delta.getElement();
    if(delta.getElement().getElementType() == IJavaElement.JAVA_PROJECT) {
        return Collections.singleton(delta);
    }
    Set<IJavaElementDelta> result = null;
    if(element instanceof IJavaModel) {
        if(delta.getAddedChildren()!=null) {
            for(IJavaElementDelta child: delta.getAffectedChildren()) {
                Set<IJavaElementDelta> projectDeltas = getProjectDeltas(child);
                if(!projectDeltas.isEmpty()) {
                    if(result == null)
                        result = newLinkedHashSet(); 
                    result.addAll(projectDeltas);
                }
            }
        }
    }
    return result == null ? Collections.<IJavaElementDelta>emptySet() : result;
}

private Set<IJavaProject> getJavaProjectsWithClasspathChange(IJavaElementDelta delta) {
    IJavaElement element = delta.getElement();
    if (element instanceof IPackageFragmentRoot) {
        IPackageFragmentRoot root = (IPackageFragmentRoot) element;
        if (delta.getKind() == IJavaElementDelta.REMOVED || delta.getKind() == IJavaElementDelta.ADDED
                || (delta.getFlags() & IJavaElementDelta.F_REORDER) != 0
                || (delta.getFlags() & IJavaElementDelta.F_REMOVED_FROM_CLASSPATH) != 0
                || (delta.getFlags() & IJavaElementDelta.F_ADDED_TO_CLASSPATH) != 0
                || (root.isExternal() && (delta.getFlags() & // external folders change
                (IJavaElementDelta.F_CONTENT | IJavaElementDelta.F_SOURCEATTACHED | IJavaElementDelta.F_SOURCEDETACHED)) == delta
                        .getFlags())) {
            return Collections.singleton(root.getJavaProject());
        }
    } else if (element instanceof IJavaModel) {
        return getPackageFragmentRootDeltas(delta.getAffectedChildren());
    } else if (element instanceof IJavaProject) {
        if ((delta.getFlags() & IJavaElementDelta.F_CLASSPATH_CHANGED) != 0
                || (delta.getFlags() & IJavaElementDelta.F_RESOLVED_CLASSPATH_CHANGED) != 0)
            return Collections.singleton((IJavaProject) element);
        return getPackageFragmentRootDeltas(delta.getAffectedChildren());
    }
    return Collections.emptySet();
}

private boolean isAffectingPackageFragmentRoots(IJavaElementDelta delta) {
    IJavaElement element = delta.getElement();
    if (element instanceof IPackageFragmentRoot) {
        if (delta.getKind() == IJavaElementDelta.REMOVED
            || delta.getKind() == IJavaElementDelta.ADDED
            || (delta.getFlags() & IJavaElementDelta.F_REORDER) != 0
            || (delta.getFlags() & IJavaElementDelta.F_REMOVED_FROM_CLASSPATH) != 0
            || (delta.getFlags() & IJavaElementDelta.F_ADDED_TO_CLASSPATH) != 0
            || (((IPackageFragmentRoot) element).isExternal() && (delta.getFlags() & // external folders change
                    (IJavaElementDelta.F_CONTENT 
                            | IJavaElementDelta.F_SOURCEATTACHED 
                            | IJavaElementDelta.F_SOURCEDETACHED)) == delta.getFlags())) {
            return true;
        }
    } else if (element instanceof IJavaModel) {
        return isAffectingPackageFragmentRoots(delta.getAffectedChildren());
    } else if (element instanceof IJavaProject) {
        if ((delta.getFlags() & IJavaElementDelta.F_CLASSPATH_CHANGED) != 0 ||
                (delta.getFlags() & IJavaElementDelta.F_RESOLVED_CLASSPATH_CHANGED) != 0)
            return true;
        return isAffectingPackageFragmentRoots(delta.getAffectedChildren());
    }
    return false;
}

public static ResourceMapping create(IJavaElement element) {
  switch (element.getElementType()) {
    case IJavaElement.TYPE:
      return create((IType) element);
    case IJavaElement.COMPILATION_UNIT:
      return create((ICompilationUnit) element);
    case IJavaElement.CLASS_FILE:
      return create((IClassFile) element);
    case IJavaElement.PACKAGE_FRAGMENT:
      return create((IPackageFragment) element);
    case IJavaElement.PACKAGE_FRAGMENT_ROOT:
      return create((IPackageFragmentRoot) element);
    case IJavaElement.JAVA_PROJECT:
      return create((IJavaProject) element);
    case IJavaElement.JAVA_MODEL:
      return create((IJavaModel) element);
    default:
      return null;
  }
}

public static boolean isDeleteAvailable(final IJavaElement element) {
  if (!element.exists()) return false;
  if (element instanceof IJavaModel || element instanceof IJavaProject) return false;
  if (element.getParent() != null && element.getParent().isReadOnly()) return false;
  if (element instanceof IPackageFragmentRoot) {
    IPackageFragmentRoot root = (IPackageFragmentRoot) element;
    if (root.isExternal() || Checks.isClasspathDelete(root)) // TODO: rename isClasspathDelete
    return false;

    if (root.getResource().equals(root.getJavaProject().getProject())) return false;
  }
  if (element.getResource() == null
      && !RefactoringAvailabilityTester.isWorkingCopyElement(element)) return false;
  if (element instanceof IMember && ((IMember) element).isBinary()) return false;
  return true;
}

@Override
protected RefactoringStatus verifyDestination(IJavaElement javaElement)
    throws JavaModelException {
  Assert.isNotNull(javaElement);
  if (!fCheckDestination) return new RefactoringStatus();
  if (!javaElement.exists())
    return RefactoringStatus.createFatalErrorStatus(
        RefactoringCoreMessages.ReorgPolicyFactory_cannot1);
  if (javaElement instanceof IJavaModel)
    return RefactoringStatus.createFatalErrorStatus(
        RefactoringCoreMessages.ReorgPolicyFactory_jmodel);
  if (!(javaElement instanceof IJavaProject))
    return RefactoringStatus.createFatalErrorStatus(
        RefactoringCoreMessages.ReorgPolicyFactory_src2proj);
  if (javaElement.isReadOnly())
    return RefactoringStatus.createFatalErrorStatus(
        RefactoringCoreMessages.ReorgPolicyFactory_src2writable);
  if (ReorgUtils.isPackageFragmentRoot(javaElement.getJavaProject()))
    return RefactoringStatus.createFatalErrorStatus(
        RefactoringCoreMessages.ReorgPolicyFactory_src2nosrc);
  return new RefactoringStatus();
}

@Override
protected RefactoringStatus verifyDestination(IJavaElement javaElement)
    throws JavaModelException {
  Assert.isNotNull(javaElement);
  if (!fCheckDestination) return new RefactoringStatus();
  if (!javaElement.exists())
    return RefactoringStatus.createFatalErrorStatus(
        RefactoringCoreMessages.ReorgPolicyFactory_cannot1);
  if (javaElement instanceof IJavaModel)
    return RefactoringStatus.createFatalErrorStatus(
        RefactoringCoreMessages.ReorgPolicyFactory_jmodel);
  IPackageFragmentRoot destRoot = getDestinationAsPackageFragmentRoot(javaElement);
  if (!ReorgUtils.isSourceFolder(destRoot))
    return RefactoringStatus.createFatalErrorStatus(
        RefactoringCoreMessages.ReorgPolicyFactory_packages);
  return new RefactoringStatus();
}

/**
 * Tests that we find an {@link com.google.gdt.eclipse.core.sdk.Sdk} on the
 * gwt-user project.
 *
 * @throws Exception
 */
public void testFindSdkFor_GwtUserProject() throws Exception {
  GwtRuntimeTestUtilities.importGwtSourceProjects();
  try {
    IJavaModel javaModel = JavaCore.create(ResourcesPlugin.getWorkspace().getRoot());
    IJavaProject javaProject = javaModel.getJavaProject("gwt-user");
    GwtSdk sdk = GwtSdk.findSdkFor(javaProject);
    IClasspathEntry gwtUserEntry =
        JavaCore.newSourceEntry(
            javaModel.getJavaProject("gwt-user").getPath().append("core/src"),
            new IPath[] {new Path("**/super/**")});
    /*
     * NOTE: Passing null for the IClasspathAttribute array tickles a bug in
     * eclipse 3.3.
     */
    IClasspathEntry gwtDevEntry =
        JavaCore.newProjectEntry(javaModel.getJavaProject("gwt-dev").getPath(), null, false,
            new IClasspathAttribute[0] /* */, false);
    IClasspathEntry[] expected = new IClasspathEntry[] {gwtUserEntry, gwtDevEntry};
    assertEquals(expected, sdk.getClasspathEntries());
  } finally {
    GwtRuntimeTestUtilities.removeGwtSourceProjects();
  }
}

public static boolean isDeleteAvailable(final IJavaElement element) {
    if (!element.exists())
        return false;
    if (element instanceof IJavaModel || element instanceof IJavaProject)
        return false;
    if (element.getParent() != null && element.getParent().isReadOnly())
        return false;
    if (element instanceof IPackageFragmentRoot) {
        IPackageFragmentRoot root= (IPackageFragmentRoot) element;
        if (root.isExternal() || Checks.isClasspathDelete(root)) // TODO: rename isClasspathDelete
            return false;

        if (root.getResource().equals(root.getJavaProject().getProject()))
            return false;
    }
    if (element.getResource() == null && !RefactoringAvailabilityTester.isWorkingCopyElement(element))
        return false;
    if (element instanceof IMember && ((IMember) element).isBinary())
        return false;
    return true;
}

@Override
protected RefactoringStatus verifyDestination(IJavaElement javaElement) throws JavaModelException {
    Assert.isNotNull(javaElement);
    if (!fCheckDestination)
        return new RefactoringStatus();
    if (!javaElement.exists())
        return RefactoringStatus.createFatalErrorStatus(RefactoringCoreMessages.ReorgPolicyFactory_cannot1);
    if (javaElement instanceof IJavaModel)
        return RefactoringStatus.createFatalErrorStatus(RefactoringCoreMessages.ReorgPolicyFactory_jmodel);
    if (!(javaElement instanceof IJavaProject))
        return RefactoringStatus.createFatalErrorStatus(RefactoringCoreMessages.ReorgPolicyFactory_src2proj);
    if (javaElement.isReadOnly())
        return RefactoringStatus.createFatalErrorStatus(RefactoringCoreMessages.ReorgPolicyFactory_src2writable);
    if (ReorgUtils.isPackageFragmentRoot(javaElement.getJavaProject()))
        return RefactoringStatus.createFatalErrorStatus(RefactoringCoreMessages.ReorgPolicyFactory_src2nosrc);
    return new RefactoringStatus();
}

@Override
public Object[] getChildren(Object element) {
    try {
        if (element instanceof IJavaModel) {
            return concatenate(getJavaProjects((IJavaModel)element), getOpenNonJavaProjects((IJavaModel)element));
        } else {
            Object[] children= doGetChildren(element);
            ArrayList<Object> result= new ArrayList<Object>(children.length);
            for (int i= 0; i < children.length; i++) {
                IReorgDestination destination= ReorgDestinationFactory.createDestination(children[i]);
                if (fValidator.canElementBeDestination(destination) || fValidator.canChildrenBeDestinations(destination))
                    result.add(children[i]);
            }
            return result.toArray();
        }
    } catch (JavaModelException e) {
        JavaPlugin.log(e);
        return new Object[0];
    }
}

public static ResourceMapping create(IJavaElement element) {
    switch (element.getElementType()) {
        case IJavaElement.TYPE:
            return create((IType)element);
        case IJavaElement.COMPILATION_UNIT:
            return create((ICompilationUnit)element);
        case IJavaElement.CLASS_FILE:
            return create((IClassFile)element);
        case IJavaElement.PACKAGE_FRAGMENT:
            return create((IPackageFragment)element);
        case IJavaElement.PACKAGE_FRAGMENT_ROOT:
            return create((IPackageFragmentRoot)element);
        case IJavaElement.JAVA_PROJECT:
            return create((IJavaProject)element);
        case IJavaElement.JAVA_MODEL:
            return create((IJavaModel)element);
        default:
            return null;
    }

}

private void refreshJavaElements(IStructuredSelection selection, IProgressMonitor monitor) throws JavaModelException {
    Object[] selectedElements= selection.toArray();
    ArrayList<IJavaElement> javaElements= new ArrayList<IJavaElement>();
    for (int i= 0; i < selectedElements.length; i++) {
        Object curr= selectedElements[i];
        if (curr instanceof IPackageFragmentRoot) {
            javaElements.add((IPackageFragmentRoot) curr);
        } else if (curr instanceof PackageFragmentRootContainer) {
            javaElements.addAll(Arrays.asList(((PackageFragmentRootContainer) curr).getPackageFragmentRoots()));
        } else if (curr instanceof IWorkingSet) {
            IAdaptable[] members= ((IWorkingSet) curr).getElements();
            for (int k= 0; k < members.length; k++) {
                IJavaElement adapted= (IJavaElement)members[k].getAdapter(IJavaElement.class);
                if (adapted instanceof IPackageFragmentRoot) {
                    javaElements.add(adapted);
                }
            }
        }
        }
    if (!javaElements.isEmpty()) {
        IJavaModel model= JavaCore.create(ResourcesPlugin.getWorkspace().getRoot());
        model.refreshExternalArchives(javaElements.toArray(new IJavaElement[javaElements.size()]), monitor);
    }
}

@Override
public Object[] getChildren(Object parentElement) {
    try {
        if (parentElement instanceof IJavaModel)
            return concatenate(getJavaProjects((IJavaModel)parentElement), getNonJavaProjects((IJavaModel)parentElement));

        if (parentElement instanceof PackageFragmentRootContainer)
            return getContainerPackageFragmentRoots((PackageFragmentRootContainer)parentElement);

        if (parentElement instanceof IProject) {
            IProject project= (IProject) parentElement;
            if (project.isAccessible())
                return project.members();
            return NO_CHILDREN;
        }

        return super.getChildren(parentElement);
    } catch (CoreException e) {
        return NO_CHILDREN;
    }
}

private String getQualification(Object element) {
    StringBuffer res= new StringBuffer();

    ITreeContentProvider provider= (ITreeContentProvider) fPage.getViewer().getContentProvider();
    Object visibleParent= provider.getParent(element);
    Object realParent= fContentProvider.getParent(element);
    Object lastElement= element;
    while (realParent != null && !(realParent instanceof IJavaModel) && !realParent.equals(visibleParent)) {
        if (!isSameInformation(realParent, lastElement))  {
            res.append(JavaElementLabels.CONCAT_STRING).append(internalGetText(realParent));
        }
        lastElement= realParent;
        realParent= fContentProvider.getParent(realParent);
    }
    return res.toString();
}

/**
 * Returns the dependent projects of the specified project.
 *
 * @param set
 *            the project set
 * @param project
 *            the project to get its dependent projects
 */
private void getDependentProjects(final Set<IProject> set, final IProject project) {
    Assert.isNotNull(set);
    Assert.isNotNull(project);
    final IJavaModel model= JavaCore.create(ResourcesPlugin.getWorkspace().getRoot());
    if (model != null) {
        try {
            final String name= project.getName();
            final IJavaProject[] projects= model.getJavaProjects();
            for (int index= 0; index < projects.length; index++) {
                final String[] names= projects[index].getRequiredProjectNames();
                for (int offset= 0; offset < names.length; offset++) {
                    if (name.equals(names[offset]))
                        set.add(projects[index].getProject());
                }
            }
        } catch (JavaModelException exception) {
            JavaPlugin.log(exception);
        }
    }
}

/**
 * Fuzzy search for Java project in the workspace that matches
 * the given path.
 *
 * @param path the path to match
 * @return the matching Java project or <code>null</code>
 * @since 3.2
 */
private IJavaProject findJavaProject(IPath path) {
    if (path == null)
        return null;

    String[] pathSegments= path.segments();
    IJavaModel model= JavaCore.create(JavaPlugin.getWorkspace().getRoot());
    IJavaProject[] projects;
    try {
        projects= model.getJavaProjects();
    } catch (JavaModelException e) {
        return null; // ignore - use default JRE
    }
    for (int i= 0; i < projects.length; i++) {
        IPath projectPath= projects[i].getProject().getFullPath();
        String projectSegment= projectPath.segments()[0];
        for (int j= 0; j < pathSegments.length; j++)
            if (projectSegment.equals(pathSegments[j]))
                return projects[i];
    }
    return null;
}

/**
 * Returns all accessible projects of the given Java model.
 *
 * @param model the Java model
 * @return the accessible projects of the given model
 */
private Object[] getAccessibleProjects(IJavaModel model) {
    IJavaProject[] javaProjects;
    Object[] nonJavaResources;
    try {
        javaProjects= model.getJavaProjects();
        nonJavaResources= model.getNonJavaResources();
    } catch (JavaModelException e) {
        return fParent.getChildren(model);
    }
    ArrayList<IAdaptable> result= new ArrayList<IAdaptable>(javaProjects.length + nonJavaResources.length);
    for (int i= 0; i < nonJavaResources.length; i++) {
        IProject project= (IProject)nonJavaResources[i];
        if (project.isAccessible())
            result.add(project);
    }
    for (int i= 0; i < javaProjects.length; i++) {
        IJavaProject javaProject= javaProjects[i];
        if (javaProject.getProject().isAccessible())
            result.add(javaProject);
    }
    return result.toArray(new Object[result.size()]);
}

private boolean collectCategories(IJavaElement element, IResultCollector collector) {//HashSet result, int max, LinkedHashMap lruList) {
    try {
        if (element instanceof IMember) {
            IMember member= (IMember)element;
            collector.accept(member.getCategories());
            return processChildren(member.getChildren(), collector);
        } else if (element instanceof ICompilationUnit) {
            return processChildren(((ICompilationUnit)element).getChildren(), collector);
        } else if (element instanceof IClassFile) {
            return processChildren(((IClassFile)element).getChildren(), collector);
        } else if (element instanceof IJavaModel) {
            return processChildren(((IJavaModel)element).getChildren(), collector);
        } else if (element instanceof IJavaProject) {
            return processChildren(((IJavaProject)element).getChildren(), collector);
        } else if (element instanceof IPackageFragment) {
            return processChildren(((IPackageFragment)element).getChildren(), collector);
        } else if (element instanceof IPackageFragmentRoot)  {
            return processChildren(((IPackageFragmentRoot)element).getChildren(), collector);
        }
        return false;
    } catch (JavaModelException e) {
        JavaPlugin.log(e);
        return true;
    }
}

private boolean doesChangeRequireFullBuild(List<String> removed, List<String> changed) {
    try {
        IJavaModel model= JavaCore.create(ResourcesPlugin.getWorkspace().getRoot());
        IJavaProject[] projects= model.getJavaProjects();
        for (int i= 0; i < projects.length; i++) {
            IClasspathEntry[] entries= projects[i].getRawClasspath();
            for (int k= 0; k < entries.length; k++) {
                IClasspathEntry curr= entries[k];
                if (curr.getEntryKind() == IClasspathEntry.CPE_VARIABLE) {
                    String var= curr.getPath().segment(0);
                    if (removed.contains(var) || changed.contains(var)) {
                        return true;
                    }
                }
            }
        }
    } catch (JavaModelException e) {
        return true;
    }
    return false;
}

/**
 * Converts the shape modification to use Java elements.
 *
 *
 * @param modification
 *            the shape modification to convert
 * @return returns true if the conversion took place
 */
private boolean convertToJavaElements(PipelinedShapeModification modification) {
    Object parent = modification.getParent();
    // As of 3.3, we no longer re-parent additions to IProject.
    if (parent instanceof IContainer) {
        IJavaElement element = JavaCore.create((IContainer) parent);
        if (element != null && element.exists()) {
            // we don't convert the root
            if( !(element instanceof IJavaModel) && !(element instanceof IJavaProject))
                modification.setParent(element);
            return convertToJavaElements(modification.getChildren());

        }
    }
    return false;
}

@Override
public Object[] getChildren(Object parentElement) {
    try {
        if (parentElement instanceof IJavaModel)
            return concatenate(super.getChildren(parentElement), getNonJavaProjects((IJavaModel)parentElement));

        if (parentElement instanceof IProject) {
            IProject project= (IProject) parentElement;
            if (project.isAccessible()) {
                return project.members();
            }
            return NO_CHILDREN;
        }
        return super.getChildren(parentElement);
    } catch (CoreException e) {
        return NO_CHILDREN;
    }
}

@Override
public boolean select(Viewer viewer, Object parentElement, Object element) {
    if (element instanceof IJavaModel) {
        return true;
    } else if (element instanceof JarPackageFragmentRoot) {
        return false;
    } else if (element instanceof IJavaProject) {
        return true;
    } else if (element instanceof PackageFragmentRoot) {
        return true;
    } else if (element instanceof PackageFragment) {
        PackageFragment packageFragment = (PackageFragment) element;
        if (packageFragment.isDefaultPackage()) {
            return false;
        }
        return true;
    } else if (element instanceof ICompilationUnit) {
        return true;
    }
    return false;
}

@Override
protected Control createDialogArea(Composite parent) {
    setTitle("Choose a Class");
    setMessage(message, IMessageProvider.NONE);
    Control control = super.createDialogArea(parent);
    Composite composite = new Composite((Composite) control, SWT.NONE);
    composite.setLayoutData(new GridData(GridData.FILL_BOTH));
    FillLayout layout = new FillLayout();
    composite.setLayout(layout);
    tree = new TreeViewer(composite, SWT.BORDER);
    tree.setContentProvider(new StandardJavaElementContentProvider());
    tree.addFilter(new SourceViewerFilter());
    JavaElementLabelProvider provider = new JavaElementLabelProvider();
    tree.setLabelProvider(provider);
    IJavaModel javaModel = JavaCore.create(ResourcesPlugin.getWorkspace().getRoot());
    tree.setInput(javaModel);
    tree.addSelectionChangedListener(new ISelectionChangedListener() {
        @Override
        public void selectionChanged(SelectionChangedEvent event) {
            selectionChangeHandler(event);
        }
    });
    return control;
}

public static boolean isDeleteAvailable(final IJavaElement element) {
    if (!element.exists())
        return false;
    if (element instanceof IJavaModel || element instanceof IJavaProject)
        return false;
    if (element.getParent() != null && element.getParent().isReadOnly())
        return false;
    if (element instanceof IPackageFragmentRoot) {
        IPackageFragmentRoot root= (IPackageFragmentRoot) element;
        if (root.isExternal() || Checks.isClasspathDelete(root)) // TODO: rename isClasspathDelete
            return false;

        if (root.getResource().equals(root.getJavaProject().getProject()))
            return false;
    }
    if (element.getResource() == null && !RefactoringAvailabilityTester.isWorkingCopyElement(element))
        return false;
    if (element instanceof IMember && ((IMember) element).isBinary())
        return false;
    return true;
}

@Override
protected RefactoringStatus verifyDestination(IJavaElement javaElement) throws JavaModelException {
    Assert.isNotNull(javaElement);
    if (!fCheckDestination)
        return new RefactoringStatus();
    if (!javaElement.exists())
        return RefactoringStatus.createFatalErrorStatus(RefactoringCoreMessages.ReorgPolicyFactory_cannot1);
    if (javaElement instanceof IJavaModel)
        return RefactoringStatus.createFatalErrorStatus(RefactoringCoreMessages.ReorgPolicyFactory_jmodel);
    if (!(javaElement instanceof IJavaProject))
        return RefactoringStatus.createFatalErrorStatus(RefactoringCoreMessages.ReorgPolicyFactory_src2proj);
    if (javaElement.isReadOnly())
        return RefactoringStatus.createFatalErrorStatus(RefactoringCoreMessages.ReorgPolicyFactory_src2writable);
    if (ReorgUtils.isPackageFragmentRoot(javaElement.getJavaProject()))
        return RefactoringStatus.createFatalErrorStatus(RefactoringCoreMessages.ReorgPolicyFactory_src2nosrc);
    return new RefactoringStatus();
}

@Override
public Object[] getChildren(Object element) {
    try {
        if (element instanceof IJavaModel) {
            return concatenate(getJavaProjects((IJavaModel)element), getOpenNonJavaProjects((IJavaModel)element));
        } else {
            Object[] children= doGetChildren(element);
            ArrayList<Object> result= new ArrayList<Object>(children.length);
            for (int i= 0; i < children.length; i++) {
                IReorgDestination destination= ReorgDestinationFactory.createDestination(children[i]);
                if (fValidator.canElementBeDestination(destination) || fValidator.canChildrenBeDestinations(destination))
                    result.add(children[i]);
            }
            return result.toArray();
        }
    } catch (JavaModelException e) {
        JavaPlugin.log(e);
        return new Object[0];
    }
}

public static ResourceMapping create(IJavaElement element) {
    switch (element.getElementType()) {
        case IJavaElement.TYPE:
            return create((IType)element);
        case IJavaElement.COMPILATION_UNIT:
            return create((ICompilationUnit)element);
        case IJavaElement.CLASS_FILE:
            return create((IClassFile)element);
        case IJavaElement.PACKAGE_FRAGMENT:
            return create((IPackageFragment)element);
        case IJavaElement.PACKAGE_FRAGMENT_ROOT:
            return create((IPackageFragmentRoot)element);
        case IJavaElement.JAVA_PROJECT:
            return create((IJavaProject)element);
        case IJavaElement.JAVA_MODEL:
            return create((IJavaModel)element);
        default:
            return null;
    }

}

private void refreshJavaElements(IStructuredSelection selection, IProgressMonitor monitor) throws JavaModelException {
    Object[] selectedElements= selection.toArray();
    ArrayList<IJavaElement> javaElements= new ArrayList<IJavaElement>();
    for (int i= 0; i < selectedElements.length; i++) {
        Object curr= selectedElements[i];
        if (curr instanceof IPackageFragmentRoot) {
            javaElements.add((IPackageFragmentRoot) curr);
        } else if (curr instanceof PackageFragmentRootContainer) {
            javaElements.addAll(Arrays.asList(((PackageFragmentRootContainer) curr).getPackageFragmentRoots()));
        } else if (curr instanceof IWorkingSet) {
            IAdaptable[] members= ((IWorkingSet) curr).getElements();
            for (int k= 0; k < members.length; k++) {
                IJavaElement adapted= (IJavaElement)members[k].getAdapter(IJavaElement.class);
                if (adapted instanceof IPackageFragmentRoot) {
                    javaElements.add(adapted);
                }
            }
        }
        }
    if (!javaElements.isEmpty()) {
        IJavaModel model= JavaCore.create(ResourcesPlugin.getWorkspace().getRoot());
        model.refreshExternalArchives(javaElements.toArray(new IJavaElement[javaElements.size()]), monitor);
    }
}

@Override
public Object[] getChildren(Object parentElement) {
    try {
        if (parentElement instanceof IJavaModel)
            return concatenate(getJavaProjects((IJavaModel)parentElement), getNonJavaProjects((IJavaModel)parentElement));

        if (parentElement instanceof PackageFragmentRootContainer)
            return getContainerPackageFragmentRoots((PackageFragmentRootContainer)parentElement);

        if (parentElement instanceof IProject) {
            IProject project= (IProject) parentElement;
            if (project.isAccessible())
                return project.members();
            return NO_CHILDREN;
        }

        return super.getChildren(parentElement);
    } catch (CoreException e) {
        return NO_CHILDREN;
    }
}

private String getQualification(Object element) {
    StringBuffer res= new StringBuffer();

    ITreeContentProvider provider= (ITreeContentProvider) fPage.getViewer().getContentProvider();
    Object visibleParent= provider.getParent(element);
    Object realParent= fContentProvider.getParent(element);
    Object lastElement= element;
    while (realParent != null && !(realParent instanceof IJavaModel) && !realParent.equals(visibleParent)) {
        if (!isSameInformation(realParent, lastElement))  {
            res.append(JavaElementLabels.CONCAT_STRING).append(internalGetText(realParent));
        }
        lastElement= realParent;
        realParent= fContentProvider.getParent(realParent);
    }
    return res.toString();
}