descent.internal.ui.wizards.buildpaths.newsourcepage.ExcludeFromBuildpathAction.java Source code

Java tutorial

Introduction

Here is the source code for descent.internal.ui.wizards.buildpaths.newsourcepage.ExcludeFromBuildpathAction.java

Source

/*******************************************************************************
 * Copyright (c) 2000, 2006 IBM Corporation and others.
 * All rights reserved. This program and the accompanying materials
 * are made available under the terms of the Eclipse Public License v1.0
 * which accompanies this distribution, and is available at
 * http://www.eclipse.org/legal/epl-v10.html
 *
 * Contributors:
 *     IBM Corporation - initial API and implementation
 *******************************************************************************/
package descent.internal.ui.wizards.buildpaths.newsourcepage;

import java.lang.reflect.InvocationTargetException;
import java.util.ArrayList;
import java.util.Iterator;
import java.util.List;

import org.eclipse.core.runtime.CoreException;
import org.eclipse.core.runtime.IProgressMonitor;
import org.eclipse.core.runtime.IStatus;
import org.eclipse.core.runtime.NullProgressMonitor;
import org.eclipse.core.runtime.SubProgressMonitor;

import org.eclipse.core.resources.IResource;

import org.eclipse.swt.widgets.Shell;

import org.eclipse.jface.action.Action;
import org.eclipse.jface.dialogs.ErrorDialog;
import org.eclipse.jface.dialogs.MessageDialog;
import org.eclipse.jface.operation.IRunnableWithProgress;
import org.eclipse.jface.viewers.ISelection;
import org.eclipse.jface.viewers.ISelectionChangedListener;
import org.eclipse.jface.viewers.IStructuredSelection;
import org.eclipse.jface.viewers.SelectionChangedEvent;
import org.eclipse.jface.viewers.StructuredSelection;

import org.eclipse.ui.IWorkbenchPage;
import org.eclipse.ui.IWorkbenchPart;
import org.eclipse.ui.IWorkbenchPartReference;
import org.eclipse.ui.IWorkbenchSite;
import org.eclipse.ui.PlatformUI;
import org.eclipse.ui.part.ISetSelectionTarget;

import descent.core.ICompilationUnit;
import descent.core.IJavaElement;
import descent.core.IJavaProject;
import descent.core.IPackageFragment;
import descent.core.IPackageFragmentRoot;
import descent.core.JavaModelException;

import descent.internal.corext.buildpath.ClasspathModifier;

import descent.internal.ui.JavaPlugin;
import descent.internal.ui.JavaPluginImages;
import descent.internal.ui.wizards.NewWizardMessages;
import descent.internal.ui.wizards.buildpaths.CPListElement;

public class ExcludeFromBuildpathAction extends Action implements ISelectionChangedListener {

    private final IWorkbenchSite fSite;
    private final List fSelectedElements; //IPackageFragment || ICompilationUnit iff isEnabled()

    public ExcludeFromBuildpathAction(IWorkbenchSite site) {
        super(NewWizardMessages.NewSourceContainerWorkbookPage_ToolBar_Exclude_label,
                JavaPluginImages.DESC_ELCL_EXCLUDE_FROM_BUILDPATH);
        setToolTipText(NewWizardMessages.NewSourceContainerWorkbookPage_ToolBar_Exclude_tooltip);
        setDisabledImageDescriptor(JavaPluginImages.DESC_DLCL_EXCLUDE_FROM_BUILDPATH);
        fSite = site;
        fSelectedElements = new ArrayList();
    }

    /**
     * {@inheritDoc}
     */
    public void run() {
        final IJavaProject project;
        Object object = fSelectedElements.get(0);
        if (object instanceof ICompilationUnit) {
            project = ((ICompilationUnit) object).getJavaProject();
        } else {
            project = ((IPackageFragment) object).getJavaProject();
        }

        try {
            final IRunnableWithProgress runnable = new IRunnableWithProgress() {
                public void run(IProgressMonitor monitor) throws InvocationTargetException, InterruptedException {
                    try {
                        List result = exclude(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 List exclude(List javaElements, IJavaProject project, IProgressMonitor monitor)
            throws JavaModelException {
        if (monitor == null)
            monitor = new NullProgressMonitor();
        try {
            monitor.beginTask(NewWizardMessages.ClasspathModifier_Monitor_Excluding, javaElements.size() + 4);

            List existingEntries = ClasspathModifier.getExistingEntries(project);
            List resources = new ArrayList();
            for (int i = 0; i < javaElements.size(); i++) {
                IJavaElement javaElement = (IJavaElement) javaElements.get(i);
                IPackageFragmentRoot root = (IPackageFragmentRoot) javaElement
                        .getAncestor(IJavaElement.PACKAGE_FRAGMENT_ROOT);
                CPListElement entry = ClasspathModifier.getClasspathEntry(existingEntries, root);

                IResource resource = ClasspathModifier.exclude(javaElement, entry, project,
                        new SubProgressMonitor(monitor, 1));
                if (resource != null) {
                    resources.add(resource);
                }
            }

            ClasspathModifier.commitClassPath(existingEntries, project, new SubProgressMonitor(monitor, 4));
            return resources;
        } finally {
            monitor.done();
        }
    }

    /**
     * {@inheritDoc}
     */
    public void selectionChanged(final SelectionChangedEvent event) {
        final ISelection selection = event.getSelection();
        if (selection instanceof IStructuredSelection) {
            setEnabled(canHandle((IStructuredSelection) selection));
        } else {
            setEnabled(canHandle(StructuredSelection.EMPTY));
        }
    }

    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 IPackageFragment) {
                    int type = DialogPackageExplorerActionGroup.getType(element,
                            ((IPackageFragment) element).getJavaProject());
                    if (type != DialogPackageExplorerActionGroup.INCLUDED_FOLDER
                            && type != DialogPackageExplorerActionGroup.PACKAGE_FRAGMENT)
                        return false;
                } else if (element instanceof ICompilationUnit) {
                } else {
                    return false;
                }
            }
            return true;
        } catch (CoreException e) {
        }
        return false;
    }

    private void showExceptionDialog(CoreException exception) {
        showError(exception, fSite.getShell(), NewWizardMessages.ExcludeFromBuildathAction_ErrorTitle,
                exception.getMessage());
    }

    private void showError(CoreException e, Shell shell, String title, String message) {
        IStatus status = e.getStatus();
        if (status != null) {
            ErrorDialog.openError(shell, message, title, status);
        } else {
            MessageDialog.openError(shell, title, message);
        }
    }

    private void selectAndReveal(final ISelection selection) {
        // validate the input
        IWorkbenchPage page = fSite.getPage();
        if (page == null)
            return;

        // get all the view and editor parts
        List parts = new ArrayList();
        IWorkbenchPartReference refs[] = page.getViewReferences();
        for (int i = 0; i < refs.length; i++) {
            IWorkbenchPart part = refs[i].getPart(false);
            if (part != null)
                parts.add(part);
        }
        refs = page.getEditorReferences();
        for (int i = 0; i < refs.length; i++) {
            if (refs[i].getPart(false) != null)
                parts.add(refs[i].getPart(false));
        }

        Iterator itr = parts.iterator();
        while (itr.hasNext()) {
            IWorkbenchPart part = (IWorkbenchPart) itr.next();

            // get the part's ISetSelectionTarget implementation
            ISetSelectionTarget target = null;
            if (part instanceof ISetSelectionTarget)
                target = (ISetSelectionTarget) part;
            else
                target = (ISetSelectionTarget) part.getAdapter(ISetSelectionTarget.class);

            if (target != null) {
                // select and reveal resource
                final ISetSelectionTarget finalTarget = target;
                page.getWorkbenchWindow().getShell().getDisplay().asyncExec(new Runnable() {
                    public void run() {
                        finalTarget.selectReveal(selection);
                    }
                });
            }
        }
    }

}