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