/** {@inheritDoc} */
  public void run() {
    IResource resource = (IResource) fSelectedElements.get(0);
    final IJavaProject project = JavaCore.create(resource.getProject());

    try {
      final IRunnableWithProgress runnable =
          new IRunnableWithProgress() {
            public void run(IProgressMonitor monitor)
                throws InvocationTargetException, InterruptedException {
              try {
                List result = unExclude(fSelectedElements, project, monitor);
                selectAndReveal(new StructuredSelection(result));
              } catch (CoreException e) {
                throw new InvocationTargetException(e);
              }
            }
          };
      PlatformUI.getWorkbench().getProgressService().run(true, false, runnable);
    } catch (final InvocationTargetException e) {
      if (e.getCause() instanceof CoreException) {
        showExceptionDialog((CoreException) e.getCause());
      } else {
        JavaPlugin.log(e);
      }
    } catch (final InterruptedException e) {
    }
  }
  private boolean canHandle(IStructuredSelection elements) {
    if (elements.size() == 0) return false;

    try {
      fSelectedElements.clear();
      for (Iterator iter = elements.iterator(); iter.hasNext(); ) {
        Object element = iter.next();
        fSelectedElements.add(element);
        if (element instanceof IResource) {
          IResource resource = (IResource) element;
          IJavaProject project = JavaCore.create(resource.getProject());
          if (project == null || !project.exists()) return false;

          if (!ClasspathModifier.isExcluded(resource, project)) return false;
        } else {
          return false;
        }
      }
      return true;
    } catch (CoreException e) {
    }
    return false;
  }
  public boolean execute(IProgressMonitor progressMonitor) {

    if (this.isCancelled || progressMonitor != null && progressMonitor.isCanceled()) return true;
    if (!project.isAccessible()) return true; // nothing to do
    IResource folder = this.project.getParent().findMember(this.folderPath);
    if (folder == null || folder.getType() == IResource.FILE)
      return true; // nothing to do, source folder was removed

    /* ensure no concurrent write access to index */
    Index index =
        this.manager.getIndex(
            this.containerPath, true, /*reuse index file*/ true /*create if none*/);
    if (index == null) return true;
    ReadWriteMonitor monitor = index.monitor;
    if (monitor == null) return true; // index got deleted since acquired

    try {
      monitor.enterRead(); // ask permission to read

      final IPath container = this.containerPath;
      final IndexManager indexManager = this.manager;
      final SourceElementParser parser =
          indexManager.getSourceElementParser(
              JavaCore.create(this.project), null /*requestor will be set by indexer*/);
      if (this.exclusionPatterns == null && this.inclusionPatterns == null) {
        folder.accept(
            new IResourceProxyVisitor() {
              public boolean visit(IResourceProxy proxy) /* throws CoreException */ {
                if (proxy.getType() == IResource.FILE) {
                  if (descent.internal.core.util.Util.isJavaLikeFileName(proxy.getName()))
                    indexManager.addSource((IFile) proxy.requestResource(), container, parser);
                  return false;
                }
                return true;
              }
            },
            IResource.NONE);
      } else {
        folder.accept(
            new IResourceProxyVisitor() {
              public boolean visit(IResourceProxy proxy) /* throws CoreException */ {
                switch (proxy.getType()) {
                  case IResource.FILE:
                    if (descent.internal.core.util.Util.isJavaLikeFileName(proxy.getName())) {
                      IResource resource = proxy.requestResource();
                      if (!Util.isExcluded(resource, inclusionPatterns, exclusionPatterns))
                        indexManager.addSource((IFile) resource, container, parser);
                    }
                    return false;
                  case IResource.FOLDER:
                    if (exclusionPatterns != null && inclusionPatterns == null) {
                      // if there are inclusion patterns then we must walk the children
                      if (Util.isExcluded(
                          proxy.requestFullPath(), inclusionPatterns, exclusionPatterns, true))
                        return false;
                    }
                }
                return true;
              }
            },
            IResource.NONE);
      }
    } catch (CoreException e) {
      if (JobManager.VERBOSE) {
        Util.verbose(
            "-> failed to add " + this.folderPath + " to index because of the following exception:",
            System.err); // $NON-NLS-1$ //$NON-NLS-2$
        e.printStackTrace();
      }
      return false;
    } finally {
      monitor.exitRead(); // free read lock
    }
    return true;
  }
 /** Convenience method to get access to the java model. */
 protected static IJavaModel getJavaModel() {
   return JavaCore.create(getWorkspaceRoot());
 }