tmf/org.eclipse.tracecompass.tmf.ui/src/org/eclipse/tracecompass/internal/tmf/ui/project/handlers/DeleteTraceFolderElementHandler.java

   1 /*******************************************************************************
   2  * Copyright (c) 2009, 2014 Ericsson, École Polytechnique de Montréal
   3  *
   4  * All rights reserved. This program and the accompanying materials are
   5  * made available under the terms of the Eclipse Public License v1.0 which
   6  * accompanies this distribution, and is available at
   7  * http://www.eclipse.org/legal/epl-v10.html
   8  *
   9  * Contributors:
  10  *   Francois Chouinard - Initial API and implementation
  11  *   Patrick Tasse - Close editors to release resources
  12  *   Geneviève Bastien - Moved the delete code to element model's classes
  13  *   Marc-Andre Laperle - Merged DeleteTraceHandler and DeleteFolderHandler
  14  *******************************************************************************/
  15
  16 package org.eclipse.tracecompass.internal.tmf.ui.project.handlers;
  17
  18 import java.lang.reflect.InvocationTargetException;
  19 import java.util.Iterator;
  20
  21 import org.eclipse.core.commands.AbstractHandler;
  22 import org.eclipse.core.commands.ExecutionEvent;
  23 import org.eclipse.core.commands.ExecutionException;
  24 import org.eclipse.core.resources.IResource;
  25 import org.eclipse.core.resources.IResourceVisitor;
  26 import org.eclipse.core.runtime.CoreException;
  27 import org.eclipse.core.runtime.IProgressMonitor;
  28 import org.eclipse.core.runtime.OperationCanceledException;
  29 import org.eclipse.core.runtime.SubMonitor;
  30 import org.eclipse.core.runtime.SubProgressMonitor;
  31 import org.eclipse.jface.viewers.ISelection;
  32 import org.eclipse.jface.viewers.ISelectionProvider;
  33 import org.eclipse.jface.viewers.IStructuredSelection;
  34 import org.eclipse.jface.viewers.TreeSelection;
  35 import org.eclipse.swt.SWT;
  36 import org.eclipse.swt.widgets.Display;
  37 import org.eclipse.swt.widgets.MessageBox;
  38 import org.eclipse.swt.widgets.Shell;
  39 import org.eclipse.tracecompass.internal.tmf.ui.Activator;
  40 import org.eclipse.tracecompass.internal.tmf.ui.project.operations.TmfWorkspaceModifyOperation;
  41 import org.eclipse.tracecompass.tmf.ui.project.model.TmfExperimentElement;
  42 import org.eclipse.tracecompass.tmf.ui.project.model.TmfTraceElement;
  43 import org.eclipse.tracecompass.tmf.ui.project.model.TmfTraceFolder;
  44 import org.eclipse.tracecompass.tmf.ui.project.model.TmfTracesFolder;
  45 import org.eclipse.tracecompass.tmf.ui.project.model.TraceUtils;
  46 import org.eclipse.ui.IWorkbenchPage;
  47 import org.eclipse.ui.IWorkbenchPart;
  48 import org.eclipse.ui.IWorkbenchWindow;
  49 import org.eclipse.ui.PlatformUI;
  50 import org.eclipse.ui.handlers.HandlerUtil;
  51
  52 /**
  53  * An handler for deletion of both traces and trace folders. It allows mixing
  54  * both types of elements.
  55  */
  56 public class DeleteTraceFolderElementHandler extends AbstractHandler {
  57
  58     private TreeSelection fSelection = null;
  59
  60     private enum DeleteType {
  61         /**
  62          * Only trace folders are selected.
  63          */
  64         DELETE_TRACE_FOLDERS,
  65         /**
  66          * Only traces are selected.
  67          */
  68         DELETE_TRACES,
  69         /**
  70          * A mix of different elements are selected.
  71          */
  72         DELETE_GENERIC,
  73         /**
  74          * Only Traces (top trace folders) are selected.
  75          */
  76         CLEAR_TRACES_FOLDER,
  77         /**
  78          * Only Traces under experiments are selected.
  79          */
  80         REMOVE_TRACES_FROM_EXPERIMENT
  81     }
  82
  83     // ------------------------------------------------------------------------
  84     // Validation
  85     // ------------------------------------------------------------------------
  86
  87     @Override
  88     public boolean isEnabled() {
  89
  90         // Check if we are closing down
  91         IWorkbenchWindow window = PlatformUI.getWorkbench().getActiveWorkbenchWindow();
  92         if (window == null) {
  93             return false;
  94         }
  95
  96         // Get the selection
  97         IWorkbenchPage page = PlatformUI.getWorkbench().getActiveWorkbenchWindow().getActivePage();
  98         IWorkbenchPart part = page.getActivePart();
  99         if (part == null) {
 100             return false;
 101         }
 102         ISelectionProvider selectionProvider = part.getSite().getSelectionProvider();
 103         if (selectionProvider == null) {
 104             return false;
 105         }
 106         ISelection selection = selectionProvider.getSelection();
 107
 108         // Make sure selection contains only traces and trace folders
 109         fSelection = null;
 110         if (selection instanceof TreeSelection) {
 111             fSelection = (TreeSelection) selection;
 112             Iterator<Object> iterator = fSelection.iterator();
 113             while (iterator.hasNext()) {
 114                 Object element = iterator.next();
 115                 if (!(element instanceof TmfTraceElement) && !(element instanceof TmfTraceFolder)) {
 116                     return false;
 117                 }
 118             }
 119         }
 120
 121         // If we get here, either nothing is selected or everything is a trace or folder
 122         return !selection.isEmpty();
 123     }
 124
 125     // ------------------------------------------------------------------------
 126     // Execution
 127     // ------------------------------------------------------------------------
 128
 129     private static DeleteType getDeleteType(ISelection selection) {
 130         int numTracesFolder = 0;
 131         int numTraceFolder = 0;
 132         int numTraces = 0;
 133         int numTracesUnderExperiment = 0;
 134
 135         @SuppressWarnings("rawtypes")
 136         Iterator iterator = ((IStructuredSelection) selection).iterator();
 137         while (iterator.hasNext()) {
 138             Object next = iterator.next();
 139             if ((next instanceof TmfTracesFolder)) {
 140                 numTracesFolder++;
 141             } else if (next instanceof TmfTraceFolder) {
 142                 numTraceFolder++;
 143             } else if (next instanceof TmfTraceElement) {
 144                 TmfTraceElement traceElement = (TmfTraceElement) next;
 145                 if (traceElement.getParent() instanceof TmfExperimentElement) {
 146                     numTracesUnderExperiment++;
 147                 } else {
 148                     numTraces++;
 149                 }
 150             }
 151         }
 152
 153         int total = numTraceFolder + numTracesFolder + numTracesUnderExperiment + numTraces;
 154
 155         if (numTracesFolder == total) {
 156             return DeleteType.CLEAR_TRACES_FOLDER;
 157         }
 158
 159         if (numTraceFolder == total) {
 160             return DeleteType.DELETE_TRACE_FOLDERS;
 161         }
 162
 163         if (numTraces == total) {
 164             return DeleteType.DELETE_TRACES;
 165         }
 166
 167         if (numTracesUnderExperiment == total) {
 168             return DeleteType.REMOVE_TRACES_FROM_EXPERIMENT;
 169         }
 170
 171         return DeleteType.DELETE_GENERIC;
 172     }
 173
 174     private static String getTitle(final DeleteType deleteType) {
 175         switch (deleteType)
 176         {
 177         case DELETE_GENERIC:
 178         case DELETE_TRACES:
 179         case DELETE_TRACE_FOLDERS:
 180             return Messages.DeleteDialog_Title;
 181         case CLEAR_TRACES_FOLDER:
 182             return Messages.ClearDialog_Title;
 183         case REMOVE_TRACES_FROM_EXPERIMENT:
 184             return Messages.RemoveDialog_Title;
 185         default:
 186             throw new IllegalArgumentException();
 187         }
 188     }
 189
 190     private static String getMessage(DeleteType deleteType) {
 191         switch (deleteType)
 192         {
 193         case DELETE_GENERIC:
 194             return Messages.DeleteTraceHandlerGeneric_Message;
 195         case DELETE_TRACES:
 196             return Messages.DeleteTraceHandler_Message;
 197         case CLEAR_TRACES_FOLDER:
 198             return Messages.DeleteFolderHandlerClear_Message;
 199         case DELETE_TRACE_FOLDERS:
 200             return Messages.DeleteFolderHandler_Message;
 201         case REMOVE_TRACES_FROM_EXPERIMENT:
 202             return Messages.RemoveTraceFromExperimentHandler_Message;
 203         default:
 204             throw new IllegalArgumentException();
 205         }
 206     }
 207
 208     private static String getTraceErrorMessage(DeleteType deleteType) {
 209         return deleteType == DeleteType.REMOVE_TRACES_FROM_EXPERIMENT ? Messages.RemoveTraceFromExperimentHandler_Error : Messages.DeleteFolderHandler_Error;
 210     }
 211
 212     private static String getFolderErrorMessage(DeleteType deleteType) {
 213         return deleteType == DeleteType.CLEAR_TRACES_FOLDER ? Messages.DeleteFolderHandlerClear_Error : Messages.DeleteFolderHandler_Error;
 214     }
 215
 216     private static String getTraceTaskName(DeleteType deleteType) {
 217         return deleteType == DeleteType.REMOVE_TRACES_FROM_EXPERIMENT ? Messages.RemoveTraceFromExperimentHandler_TaskName : Messages.DeleteFolderHandler_TaskName;
 218     }
 219
 220     private static String getTraceFolderTaskName(DeleteType deleteType) {
 221         return deleteType == DeleteType.CLEAR_TRACES_FOLDER ? Messages.DeleteFolderHandlerClear_TaskName : Messages.DeleteFolderHandler_TaskName;
 222     }
 223
 224     @Override
 225     public Object execute(ExecutionEvent event) throws ExecutionException {
 226
 227         // Check if we are closing down
 228         IWorkbenchWindow window = PlatformUI.getWorkbench().getActiveWorkbenchWindow();
 229         if (window == null) {
 230             return null;
 231         }
 232
 233         // Get the selection
 234         ISelection selection = HandlerUtil.getCurrentSelection(event);
 235         if (!(selection instanceof IStructuredSelection)) {
 236             return null;
 237         }
 238         final DeleteType deleteType = getDeleteType(selection);
 239
 240         // Confirm the operation
 241         Shell shell = window.getShell();
 242         MessageBox confirmOperation = new MessageBox(shell, SWT.ICON_QUESTION | SWT.CANCEL | SWT.OK);
 243         confirmOperation.setText(getTitle(deleteType));
 244         confirmOperation.setMessage(getMessage(deleteType));
 245         if (confirmOperation.open() != SWT.OK) {
 246             return null;
 247         }
 248
 249         final Iterator<Object> iterator = fSelection.iterator();
 250         final int nbElements = fSelection.size();
 251
 252         TmfWorkspaceModifyOperation operation = new TmfWorkspaceModifyOperation() {
 253             @Override
 254             public void execute(IProgressMonitor monitor) throws CoreException {
 255                 SubMonitor subMonitor = SubMonitor.convert(monitor, nbElements);
 256
 257                 while (iterator.hasNext()) {
 258                     if (monitor.isCanceled()) {
 259                         throw new OperationCanceledException();
 260                     }
 261                     Object element = iterator.next();
 262                     SubProgressMonitor elementSubMonitor = new SubProgressMonitor(subMonitor, 1);
 263                     if (element instanceof TmfTraceElement) {
 264                         final TmfTraceElement trace = (TmfTraceElement) element;
 265                         if (!trace.getResource().exists()) {
 266                             continue;
 267                         }
 268                         subMonitor.setTaskName(getTraceTaskName(deleteType) + " " + trace.getElementPath()); //$NON-NLS-1$
 269                         try {
 270                             SubMonitor deleteSubMonitor = SubMonitor.convert(elementSubMonitor, 1);
 271                             trace.delete(deleteSubMonitor);
 272                         } catch (final CoreException e) {
 273                             Display.getDefault().asyncExec(new Runnable() {
 274                                 @Override
 275                                 public void run() {
 276                                     final MessageBox mb = new MessageBox(PlatformUI.getWorkbench().getActiveWorkbenchWindow().getShell());
 277                                     mb.setText(getTraceErrorMessage(deleteType) + ' ' + trace.getName());
 278                                     mb.setMessage(e.getMessage());
 279                                     mb.open();
 280                                 }
 281                             });
 282                             Activator.getDefault().logError(getTraceErrorMessage(deleteType) + trace.getName(), e);
 283                         }
 284                     } else if (element instanceof TmfTraceFolder) {
 285                         final TmfTraceFolder folder = (TmfTraceFolder) element;
 286                         final IResource resource = folder.getResource();
 287                         if (!resource.exists()) {
 288                             continue;
 289                         }
 290
 291                         subMonitor.setTaskName(getTraceFolderTaskName(deleteType) + " " + folder.getPath()); //$NON-NLS-1$
 292
 293                         try {
 294                             // delete all traces under this folder
 295                             SubMonitor childrenSubMonitor = SubMonitor.convert(elementSubMonitor, folder.getTraces().size() + 1);
 296                             for (TmfTraceElement traceElement : folder.getTraces()) {
 297                                 SubProgressMonitor deleteSubMonitor = new SubProgressMonitor(childrenSubMonitor, 1);
 298                                 traceElement.delete(deleteSubMonitor);
 299                             }
 300
 301                             // Finally, delete the folder. For the Traces
 302                             // folder, we only delete the children since the
 303                             // folder should always be there.
 304                             final SubProgressMonitor deleteSubMonitor = new SubProgressMonitor(subMonitor, 1);
 305                             if (folder instanceof TmfTracesFolder) {
 306                                 resource.accept(new IResourceVisitor() {
 307                                     @Override
 308                                     public boolean visit(IResource visitedResource) throws CoreException {
 309                                         if (visitedResource != resource) {
 310                                             visitedResource.delete(true, deleteSubMonitor);
 311                                         }
 312                                         return true;
 313                                     }
 314                                 }, IResource.DEPTH_ONE, 0);
 315                             } else {
 316                                 resource.delete(true, deleteSubMonitor);
 317                             }
 318                             childrenSubMonitor.done();
 319                         } catch (final CoreException e) {
 320                             Display.getDefault().asyncExec(new Runnable() {
 321                                 @Override
 322                                 public void run() {
 323                                     final MessageBox mb = new MessageBox(PlatformUI.getWorkbench().getActiveWorkbenchWindow().getShell());
 324                                     mb.setText(getFolderErrorMessage(deleteType) + ' ' + folder.getName());
 325                                     mb.setMessage(e.getMessage());
 326                                     mb.open();
 327                                 }
 328                             });
 329                             Activator.getDefault().logError(getFolderErrorMessage(deleteType) + folder.getName(), e);
 330                         }
 331                     }
 332                     subMonitor.setTaskName(""); //$NON-NLS-1$
 333                     elementSubMonitor.done();
 334                 }
 335            }
 336         };
 337
 338         try {
 339             PlatformUI.getWorkbench().getProgressService().run(true, true, operation);
 340         } catch (InterruptedException e) {
 341             return null;
 342         } catch (InvocationTargetException e) {
 343             TraceUtils.displayErrorMsg(e.toString(), e.getTargetException().toString());
 344             return null;
 345         }
 346         return null;
 347     }
 348
 349 }