case-study/jdt-before/ui/org/eclipse/jdt/internal/ui/wizards/buildpaths/newsourcepage/RemoveFromBuildpathAction.java

   1 /*******************************************************************************
   2  * Copyright (c) 2000, 2011 IBM Corporation and others.
   3  * All rights reserved. This program and the accompanying materials
   4  * are made available under the terms of the Eclipse Public License v1.0
   5  * which accompanies this distribution, and is available at
   6  * http://www.eclipse.org/legal/epl-v10.html
   7  *
   8  * Contributors:
   9  *     IBM Corporation - initial API and implementation
  10  *******************************************************************************/
  11 package org.eclipse.jdt.internal.ui.wizards.buildpaths.newsourcepage;
  12
  13 import java.lang.reflect.InvocationTargetException;
  14 import java.util.ArrayList;
  15 import java.util.Arrays;
  16 import java.util.Iterator;
  17 import java.util.List;
  18
  19 import org.eclipse.swt.widgets.Shell;
  20
  21 import org.eclipse.core.runtime.CoreException;
  22 import org.eclipse.core.runtime.IProgressMonitor;
  23 import org.eclipse.core.runtime.SubProgressMonitor;
  24
  25 import org.eclipse.core.resources.IFolder;
  26 import org.eclipse.core.resources.IResource;
  27
  28 import org.eclipse.jface.operation.IRunnableContext;
  29 import org.eclipse.jface.operation.IRunnableWithProgress;
  30 import org.eclipse.jface.viewers.IStructuredSelection;
  31 import org.eclipse.jface.viewers.StructuredSelection;
  32 import org.eclipse.jface.window.Window;
  33
  34 import org.eclipse.ui.IWorkbenchSite;
  35 import org.eclipse.ui.PlatformUI;
  36 import org.eclipse.ui.part.ISetSelectionTarget;
  37
  38 import org.eclipse.jdt.core.IClasspathEntry;
  39 import org.eclipse.jdt.core.IJavaElement;
  40 import org.eclipse.jdt.core.IJavaProject;
  41 import org.eclipse.jdt.core.IPackageFragmentRoot;
  42 import org.eclipse.jdt.core.JavaModelException;
  43
  44 import org.eclipse.jdt.internal.corext.buildpath.BuildpathDelta;
  45 import org.eclipse.jdt.internal.corext.buildpath.CPJavaProject;
  46 import org.eclipse.jdt.internal.corext.buildpath.ClasspathModifier;
  47 import org.eclipse.jdt.internal.corext.util.JavaModelUtil;
  48 import org.eclipse.jdt.internal.corext.util.Messages;
  49
  50 import org.eclipse.jdt.ui.JavaElementLabels;
  51
  52 import org.eclipse.jdt.internal.ui.JavaPlugin;
  53 import org.eclipse.jdt.internal.ui.JavaPluginImages;
  54 import org.eclipse.jdt.internal.ui.packageview.ClassPathContainer;
  55 import org.eclipse.jdt.internal.ui.wizards.NewWizardMessages;
  56 import org.eclipse.jdt.internal.ui.wizards.buildpaths.CPListElement;
  57 import org.eclipse.jdt.internal.ui.wizards.buildpaths.newsourcepage.ClasspathModifierQueries.IRemoveLinkedFolderQuery;
  58
  59 //SelectedElements iff enabled: IPackageFramgentRoot || IJavaProject || ClassPathContainer
  60 public class RemoveFromBuildpathAction extends BuildpathModifierAction {
  61
  62         private final IRunnableContext fContext;
  63
  64         public RemoveFromBuildpathAction(IWorkbenchSite site) {
  65                 this(site, null, PlatformUI.getWorkbench().getProgressService());
  66
  67                 setImageDescriptor(JavaPluginImages.DESC_ELCL_REMOVE_FROM_BP);
  68         }
  69
  70         public RemoveFromBuildpathAction(IRunnableContext context, ISetSelectionTarget selectionTarget) {
  71                 this(null, selectionTarget, context);
  72
  73                 setImageDescriptor(JavaPluginImages.DESC_ELCL_REMOVE_AS_SOURCE_FOLDER);
  74                 setDisabledImageDescriptor(JavaPluginImages.DESC_DLCL_REMOVE_AS_SOURCE_FOLDER);
  75     }
  76
  77         public RemoveFromBuildpathAction(IWorkbenchSite site, ISetSelectionTarget selectionTarget, IRunnableContext context) {
  78                 super(site, selectionTarget, BuildpathModifierAction.REMOVE_FROM_BP);
  79
  80                 fContext= context;
  81
  82                 setText(NewWizardMessages.NewSourceContainerWorkbookPage_ToolBar_RemoveFromCP_label);
  83                 setToolTipText(NewWizardMessages.NewSourceContainerWorkbookPage_ToolBar_RemoveFromCP_tooltip);
  84     }
  85
  86         /**
  87          * {@inheritDoc}
  88          */
  89         @Override
  90         public String getDetailedDescription() {
  91                 if (!isEnabled())
  92                         return null;
  93
  94                 if (getSelectedElements().size() != 1)
  95                         return NewWizardMessages.PackageExplorerActionGroup_FormText_Default_FromBuildpath;
  96
  97                 Object elem= getSelectedElements().get(0);
  98
  99         if (elem instanceof IJavaProject) {
 100             String name= ClasspathModifier.escapeSpecialChars(JavaElementLabels.getElementLabel(((IJavaElement)elem), JavaElementLabels.ALL_DEFAULT));
 101                 return Messages.format(NewWizardMessages.PackageExplorerActionGroup_FormText_ProjectFromBuildpath, name);
 102         } else if (elem instanceof IPackageFragmentRoot) {
 103             String name= ClasspathModifier.escapeSpecialChars(JavaElementLabels.getElementLabel(((IJavaElement)elem), JavaElementLabels.ALL_DEFAULT));
 104                 return Messages.format(NewWizardMessages.PackageExplorerActionGroup_FormText_fromBuildpath, name);
 105         } else if (elem instanceof ClassPathContainer) {
 106                 return NewWizardMessages.PackageExplorerActionGroup_FormText_Default_FromBuildpath;
 107         }
 108
 109         return null;
 110         }
 111
 112         /**
 113          * {@inheritDoc}
 114          */
 115         @Override
 116         public void run() {
 117                 try {
 118
 119                         final IJavaProject project;
 120                         Object object= getSelectedElements().get(0);
 121                         if (object instanceof IJavaProject) {
 122                                 project= (IJavaProject)object;
 123                         } else if (object instanceof IPackageFragmentRoot) {
 124                                 IPackageFragmentRoot root= (IPackageFragmentRoot)object;
 125                                 project= root.getJavaProject();
 126                         } else {
 127                                 ClassPathContainer container= (ClassPathContainer)object;
 128                                 project= container.getJavaProject();
 129                         }
 130
 131                         final List<Object> elementsToRemove= new ArrayList<Object>();
 132                         final List<IFolder> foldersToDelete= new ArrayList<IFolder>();
 133                         queryToRemoveLinkedFolders(elementsToRemove, foldersToDelete);
 134
 135                         final IRunnableWithProgress runnable= new IRunnableWithProgress() {
 136                                 public void run(IProgressMonitor monitor) throws InvocationTargetException, InterruptedException {
 137                                         try {
 138                                                 monitor.beginTask(NewWizardMessages.ClasspathModifier_Monitor_RemoveFromBuildpath, foldersToDelete.size() + 10);
 139
 140                                                 CPJavaProject cpProject= CPJavaProject.createFromExisting(project);
 141                                                 CPListElement[] toRemove= new CPListElement[elementsToRemove.size()];
 142                                                 int i= 0;
 143                                                 for (Iterator<Object> iterator= elementsToRemove.iterator(); iterator.hasNext();) {
 144                                                         Object element= iterator.next();
 145                                                         if (element instanceof IJavaProject) {
 146                                                                 toRemove[i]= ClasspathModifier.getListElement(((IJavaProject)element).getPath(), cpProject.getCPListElements());
 147                                                         } else if (element instanceof IPackageFragmentRoot) {
 148                                                                 toRemove[i]= CPListElement.createFromExisting(((IPackageFragmentRoot)element).getRawClasspathEntry(), project);
 149                                                         } else {
 150                                                                 toRemove[i]= CPListElement.createFromExisting(((ClassPathContainer)element).getClasspathEntry(), project);
 151                                                         }
 152                                 i++;
 153                         }
 154
 155                                                 BuildpathDelta delta= ClasspathModifier.removeFromBuildpath(toRemove, cpProject);
 156                                                 ClasspathModifier.commitClassPath(cpProject, new SubProgressMonitor(monitor, 10));
 157
 158                                                 deleteFolders(foldersToDelete, new SubProgressMonitor(monitor, foldersToDelete.size()));
 159
 160                                                 informListeners(delta);
 161
 162                                                 if (delta.getDeletedResources().length == foldersToDelete.size()) {
 163                                                         selectAndReveal(new StructuredSelection(project));
 164                                                 } else {
 165                                                         List<IResource> result= new ArrayList<IResource>(Arrays.asList(delta.getDeletedResources()));
 166                                                         result.removeAll(foldersToDelete);
 167                                                         selectAndReveal(new StructuredSelection(result));
 168                                                 }
 169                                         } catch (CoreException e) {
 170                                                 throw new InvocationTargetException(e);
 171                                         } finally {
 172                                                 monitor.done();
 173                                         }
 174                                 }
 175                         };
 176                         fContext.run(false, false, runnable);
 177
 178                 } catch (CoreException e) {
 179                         showExceptionDialog(e, NewWizardMessages.RemoveFromBuildpathAction_ErrorTitle);
 180                 } catch (InvocationTargetException e) {
 181                         if (e.getCause() instanceof CoreException) {
 182                                 showExceptionDialog((CoreException)e.getCause(), NewWizardMessages.RemoveFromBuildpathAction_ErrorTitle);
 183                         } else {
 184                                 JavaPlugin.log(e);
 185                         }
 186                 } catch (InterruptedException e) {
 187                 }
 188         }
 189
 190         private void deleteFolders(List<IFolder> folders, IProgressMonitor monitor) throws CoreException {
 191                 try {
 192                         monitor.beginTask(NewWizardMessages.ClasspathModifier_Monitor_RemoveFromBuildpath, folders.size());
 193
 194                         for (Iterator<IFolder> iter= folders.iterator(); iter.hasNext();) {
 195                                 IFolder folder= iter.next();
 196                                 folder.delete(true, true, new SubProgressMonitor(monitor, 1));
 197                         }
 198                 } finally {
 199                         monitor.done();
 200                 }
 201         }
 202
 203         private void queryToRemoveLinkedFolders(final List<Object> elementsToRemove, final List<IFolder> foldersToDelete) throws JavaModelException {
 204                 final Shell shell= getShell();
 205                 for (Iterator<?> iter= getSelectedElements().iterator(); iter.hasNext();) {
 206                         Object element= iter.next();
 207                         if (element instanceof IPackageFragmentRoot) {
 208                                 IFolder folder= getLinkedSourceFolder((IPackageFragmentRoot)element);
 209                                 if (folder != null) {
 210                                         RemoveLinkedFolderDialog dialog= new RemoveLinkedFolderDialog(shell, folder);
 211
 212                                         final int result= dialog.open() == Window.OK?dialog.getRemoveStatus():IRemoveLinkedFolderQuery.REMOVE_CANCEL;
 213
 214                                         if (result != IRemoveLinkedFolderQuery.REMOVE_CANCEL) {
 215                                                 if (result == IRemoveLinkedFolderQuery.REMOVE_BUILD_PATH) {
 216                                                         elementsToRemove.add(element);
 217                                                 } else if (result == IRemoveLinkedFolderQuery.REMOVE_BUILD_PATH_AND_FOLDER) {
 218                                                         elementsToRemove.add(element);
 219                                                         foldersToDelete.add(folder);
 220                                                 }
 221                                         }
 222                                 } else {
 223                                         elementsToRemove.add(element);
 224                                 }
 225                         } else {
 226                                 elementsToRemove.add(element);
 227                         }
 228                 }
 229         }
 230
 231         private IFolder getLinkedSourceFolder(IPackageFragmentRoot root) throws JavaModelException {
 232                 if (root.getKind() != IPackageFragmentRoot.K_SOURCE)
 233                         return null;
 234
 235                 final IResource resource= root.getCorrespondingResource();
 236                 if (!(resource instanceof IFolder))
 237                         return null;
 238
 239                 final IFolder folder= (IFolder) resource;
 240                 if (!folder.isLinked())
 241                         return null;
 242
 243                 return folder;
 244         }
 245
 246         @Override
 247         protected boolean canHandle(IStructuredSelection elements) {
 248                 if (elements.size() == 0)
 249                         return false;
 250
 251                 try {
 252                         for (Iterator<?> iter= elements.iterator(); iter.hasNext();) {
 253                                 Object element= iter.next();
 254
 255                                 if (element instanceof IJavaProject) {
 256                                         IJavaProject project= (IJavaProject)element;
 257                                         if (!ClasspathModifier.isSourceFolder(project))
 258                                                 return false;
 259
 260                                 } else if (element instanceof IPackageFragmentRoot) {
 261                                         IClasspathEntry entry= JavaModelUtil.getClasspathEntry((IPackageFragmentRoot) element);
 262                                         if (entry.getEntryKind() == IClasspathEntry.CPE_CONTAINER)
 263                                                 return false;
 264                                         if (entry.getReferencingEntry() != null)
 265                                                 return false;
 266                                 } else if (element instanceof ClassPathContainer) {
 267                                         return true;
 268                                 } else {
 269                                         return false;
 270                                 }
 271                         }
 272                         return true;
 273                 } catch (JavaModelException e) {
 274                 }
 275                 return false;
 276         }
 277 }