org.eclipse.linuxtools.tmf.ui/src/org/eclipse/linuxtools/tmf/ui/project/handlers/DropAdapterAssistant.java

   1 /*******************************************************************************
   2 * Copyright (c) 2012 Ericsson
   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  *   Patrick Tasse - Initial API and implementation
  11  *******************************************************************************/
  12
  13 package org.eclipse.linuxtools.tmf.ui.project.handlers;
  14
  15 import java.io.File;
  16 import java.lang.reflect.InvocationTargetException;
  17 import java.util.LinkedList;
  18 import java.util.List;
  19 import java.util.Map;
  20
  21 import org.eclipse.core.resources.IFile;
  22 import org.eclipse.core.resources.IFolder;
  23 import org.eclipse.core.resources.IProject;
  24 import org.eclipse.core.resources.IResource;
  25 import org.eclipse.core.resources.IWorkspace;
  26 import org.eclipse.core.resources.ResourcesPlugin;
  27 import org.eclipse.core.runtime.CoreException;
  28 import org.eclipse.core.runtime.IPath;
  29 import org.eclipse.core.runtime.IStatus;
  30 import org.eclipse.core.runtime.NullProgressMonitor;
  31 import org.eclipse.core.runtime.Path;
  32 import org.eclipse.core.runtime.QualifiedName;
  33 import org.eclipse.core.runtime.Status;
  34 import org.eclipse.jface.viewers.IStructuredSelection;
  35 import org.eclipse.linuxtools.tmf.ui.project.model.ITmfProjectModelElement;
  36 import org.eclipse.linuxtools.tmf.ui.project.model.TmfExperimentElement;
  37 import org.eclipse.linuxtools.tmf.ui.project.model.TmfProjectElement;
  38 import org.eclipse.linuxtools.tmf.ui.project.model.TmfProjectRegistry;
  39 import org.eclipse.linuxtools.tmf.ui.project.model.TmfTraceElement;
  40 import org.eclipse.linuxtools.tmf.ui.project.model.TmfTraceFolder;
  41 import org.eclipse.swt.dnd.DND;
  42 import org.eclipse.swt.dnd.DropTargetEvent;
  43 import org.eclipse.swt.dnd.FileTransfer;
  44 import org.eclipse.swt.dnd.TransferData;
  45 import org.eclipse.swt.widgets.MessageBox;
  46 import org.eclipse.ui.PlatformUI;
  47 import org.eclipse.ui.dialogs.IOverwriteQuery;
  48 import org.eclipse.ui.navigator.CommonDropAdapter;
  49 import org.eclipse.ui.navigator.CommonDropAdapterAssistant;
  50 import org.eclipse.ui.wizards.datatransfer.FileSystemStructureProvider;
  51 import org.eclipse.ui.wizards.datatransfer.ImportOperation;
  52
  53 /**
  54  * Drop adapter assistant for project explorer
  55  */
  56 public class DropAdapterAssistant extends CommonDropAdapterAssistant {
  57
  58     /**
  59      * Default constructor
  60      */
  61     public DropAdapterAssistant() {
  62     }
  63
  64     /* (non-Javadoc)
  65      * @see org.eclipse.ui.navigator.CommonDropAdapterAssistant#isSupportedType(org.eclipse.swt.dnd.TransferData)
  66      */
  67     @Override
  68     public boolean isSupportedType(TransferData aTransferType) {
  69         return super.isSupportedType(aTransferType) || FileTransfer.getInstance().isSupportedType(aTransferType);
  70     }
  71
  72     /* (non-Javadoc)
  73      * @see org.eclipse.ui.navigator.CommonDropAdapterAssistant#validateDrop(java.lang.Object, int, org.eclipse.swt.dnd.TransferData)
  74      */
  75     @Override
  76     public IStatus validateDrop(Object target, int operation, TransferData transferType) {
  77         if (target instanceof TmfTraceFolder) {
  78             getCommonDropAdapter().overrideOperation(DND.DROP_COPY);
  79             return Status.OK_STATUS;
  80         }
  81         if (target instanceof TmfExperimentElement) {
  82             getCommonDropAdapter().overrideOperation(DND.DROP_LINK);
  83             return Status.OK_STATUS;
  84         }
  85         if (target instanceof TmfTraceElement) {
  86             ITmfProjectModelElement parent = ((TmfTraceElement) target).getParent();
  87             if (parent instanceof TmfTraceFolder) {
  88                 getCommonDropAdapter().overrideOperation(DND.DROP_COPY);
  89                 return Status.OK_STATUS;
  90             }
  91             if (parent instanceof TmfExperimentElement) {
  92                 getCommonDropAdapter().overrideOperation(DND.DROP_LINK);
  93                 return Status.OK_STATUS;
  94             }
  95         }
  96         if (target instanceof IProject) {
  97             getCommonDropAdapter().overrideOperation(DND.DROP_COPY);
  98             return Status.OK_STATUS;
  99         }
 100         return Status.CANCEL_STATUS;
 101     }
 102
 103     /* (non-Javadoc)
 104      * @see org.eclipse.ui.navigator.CommonDropAdapterAssistant#handleDrop(org.eclipse.ui.navigator.CommonDropAdapter, org.eclipse.swt.dnd.DropTargetEvent, java.lang.Object)
 105      */
 106     @Override
 107     public IStatus handleDrop(CommonDropAdapter aDropAdapter, DropTargetEvent aDropTargetEvent, Object aTarget) {
 108         boolean ok = false;
 109
 110         // If target is a trace, use its parent (either trace folder or experiment)
 111         if (aTarget instanceof TmfTraceElement) {
 112             aTarget = ((TmfTraceElement) aTarget).getParent();
 113         }
 114
 115         // If target is a project, use its trace folder
 116         if (aTarget instanceof IProject) {
 117             TmfProjectElement projectElement = TmfProjectRegistry.getProject((IProject) aTarget);
 118             if (projectElement != null) {
 119                 aTarget = projectElement.getTracesFolder();
 120             }
 121         }
 122
 123         if (aDropTargetEvent.data instanceof IStructuredSelection) {
 124             IStructuredSelection selection = (IStructuredSelection) aDropTargetEvent.data;
 125             for (Object source : selection.toArray()) {
 126                 if (source instanceof IResource) {
 127                     // If source resource is a trace, use the trace element
 128                     IResource sourceResource = (IResource) source;
 129                     TmfProjectElement projectElement = TmfProjectRegistry.getProject(sourceResource.getProject());
 130                     if (projectElement != null && projectElement.getTracesFolder() != null) {
 131                         for (TmfTraceElement trace : projectElement.getTracesFolder().getTraces()) {
 132                             if (trace.getResource().equals(sourceResource)) {
 133                                 source = trace;
 134                                 break;
 135                             }
 136                         }
 137                     }
 138                 }
 139                 if (source instanceof TmfTraceElement) {
 140                     TmfTraceElement sourceTrace = (TmfTraceElement) source;
 141                     // If source trace is under an experiment, use the original trace from the traces folder
 142                     if (sourceTrace.getParent() instanceof TmfExperimentElement) {
 143                         for (TmfTraceElement trace : sourceTrace.getProject().getTracesFolder().getTraces()) {
 144                             if (trace.getName().equals(sourceTrace.getName())) {
 145                                 sourceTrace = trace;
 146                                 break;
 147                             }
 148                         }
 149                     }
 150                     IResource sourceResource = sourceTrace.getResource();
 151                     if (aTarget instanceof TmfExperimentElement) {
 152                         TmfExperimentElement targetExperiment = (TmfExperimentElement) aTarget;
 153                         ok |= drop(sourceResource, targetExperiment);
 154                     } else if (aTarget instanceof TmfTraceFolder) {
 155                         TmfTraceFolder traceFolder = (TmfTraceFolder) aTarget;
 156                         ok |= drop(sourceResource, traceFolder);
 157                     }
 158                 } else if (source instanceof IResource) {
 159                     IResource sourceResource = (IResource) source;
 160                     if (sourceResource.getType() != IResource.FILE && sourceResource.getType() != IResource.FOLDER) {
 161                         continue;
 162                     }
 163                     if (aTarget instanceof TmfExperimentElement) {
 164                         TmfExperimentElement targetExperiment = (TmfExperimentElement) aTarget;
 165                         ok |= drop(sourceResource, targetExperiment);
 166                     } else if (aTarget instanceof TmfTraceFolder) {
 167                         TmfTraceFolder traceFolder = (TmfTraceFolder) aTarget;
 168                         ok |= drop(sourceResource, traceFolder);
 169                     }
 170                 }
 171             }
 172         } else if (aDropTargetEvent.data instanceof String[]) {
 173             String[] sources = (String[]) aDropTargetEvent.data;
 174             for (String source : sources) {
 175                 Path path = new Path(source);
 176                 if (aTarget instanceof TmfExperimentElement) {
 177                     TmfExperimentElement targetExperiment = (TmfExperimentElement) aTarget;
 178                     ok |= drop(path, targetExperiment);
 179                 } else if (aTarget instanceof TmfTraceFolder) {
 180                     TmfTraceFolder traceFolder = (TmfTraceFolder) aTarget;
 181                     ok |= drop(path, traceFolder);
 182                 }
 183             }
 184         }
 185         return (ok ? Status.OK_STATUS : Status.CANCEL_STATUS);
 186     }
 187
 188     /**
 189      * Drop a trace by copying a resource in a target experiment
 190      *
 191      * @param sourceResource the source resource
 192      * @param targetExperiment the target experiment
 193      * @return true if successful
 194      */
 195     private boolean drop(IResource sourceResource, TmfExperimentElement targetExperiment) {
 196         boolean doit = true;
 197         TmfProjectElement projectElement = TmfProjectRegistry.getProject(sourceResource.getProject());
 198         for (TmfTraceElement trace : targetExperiment.getTraces()) {
 199             if (trace.getName().equals(sourceResource.getName())) {
 200                 doit = false;
 201                 break;
 202             }
 203         }
 204         if (doit && !targetExperiment.getProject().equals(projectElement)) {
 205             for (TmfTraceElement trace : targetExperiment.getProject().getTracesFolder().getTraces()) {
 206                 if (trace.getName().equals(sourceResource.getName())) {
 207                     doit = false;
 208                     break;
 209                 }
 210             }
 211             if (doit) {
 212                 try {
 213                     IPath destination = targetExperiment.getProject().getTracesFolder().getResource().getFullPath().addTrailingSeparator().append(sourceResource.getName());
 214                     sourceResource.copy(destination, false, null);
 215                     // use the copied resource for the experiment
 216                     if (sourceResource.getType() == IResource.FILE) {
 217                         sourceResource = targetExperiment.getProject().getTracesFolder().getResource().getFile(sourceResource.getName());
 218                     } else if (sourceResource.getType() == IResource.FOLDER) {
 219                         sourceResource = targetExperiment.getProject().getTracesFolder().getResource().getFolder(sourceResource.getName());
 220                     }
 221                 } catch (CoreException e) {
 222                     doit = false;
 223                     displayException(e);
 224                 }
 225             }
 226         }
 227         if (doit) {
 228             if (sourceResource != null && sourceResource.exists()) {
 229                 createLink(targetExperiment.getResource(), sourceResource);
 230                 return true;
 231             }
 232         }
 233         return false;
 234     }
 235
 236     /**
 237      * Drop a trace by copying a resource in a trace folder
 238      *
 239      * @param sourceResource the source resource
 240      * @param traceFolder the target trace folder
 241      * @return true if successful
 242      */
 243     private boolean drop(IResource sourceResource, TmfTraceFolder traceFolder) {
 244         boolean doit = true;
 245         for (TmfTraceElement trace : traceFolder.getTraces()) {
 246             if (trace.getName().equals(sourceResource.getName())) {
 247                 doit = false;
 248                 break;
 249             }
 250         }
 251         if (doit) {
 252             try {
 253                 IPath destination = traceFolder.getResource().getFullPath().addTrailingSeparator().append(sourceResource.getName());
 254                 sourceResource.copy(destination, false, null);
 255                 return true;
 256             } catch (CoreException e) {
 257                 displayException(e);
 258             }
 259         }
 260         return false;
 261     }
 262
 263     /**
 264      * Drop a trace by importing a path in a target experiment
 265      *
 266      * @param path the source path
 267      * @param targetExperiment the target experiment
 268      * @return true if successful
 269      */
 270     private boolean drop(Path path, TmfExperimentElement targetExperiment) {
 271         boolean doit = true;
 272         for (TmfTraceElement trace : targetExperiment.getTraces()) {
 273             if (trace.getName().equals(path.lastSegment())) {
 274                 doit = false;
 275                 break;
 276             }
 277         }
 278         if (doit && !path.toString().startsWith(targetExperiment.getProject().getResource().getLocation().toString())) {
 279             for (TmfTraceElement trace : targetExperiment.getProject().getTracesFolder().getTraces()) {
 280                 if (trace.getName().equals(path.lastSegment())) {
 281                     doit = false;
 282                     break;
 283                 }
 284             }
 285             if (doit) {
 286                 importTrace(targetExperiment.getProject().getTracesFolder().getResource(), path);
 287                 // use the imported trace for the experiment
 288                 path = new Path(targetExperiment.getProject().getTracesFolder().getResource().getFile(path.lastSegment()).getLocation().toString());
 289             }
 290         }
 291         if (doit) {
 292             IResource resource = null;
 293             File file = new File(path.toString());
 294             if (file.exists() && file.isFile()) {
 295                 resource = targetExperiment.getProject().getTracesFolder().getResource().getFile(path.lastSegment());
 296             } else if (file.exists() && file.isDirectory()) {
 297                 resource = targetExperiment.getProject().getTracesFolder().getResource().getFolder(path.lastSegment());
 298             }
 299             if (resource != null && resource.exists()) {
 300                 createLink(targetExperiment.getResource(), resource);
 301                 return true;
 302             }
 303         }
 304         return false;
 305     }
 306
 307     /**
 308      * Drop a trace by importing a path in a trace folder
 309      *
 310      * @param path the source path
 311      * @param traceFolder the target trace folder
 312      * @return true if successful
 313      */
 314     private boolean drop(Path path, TmfTraceFolder traceFolder) {
 315         boolean doit = true;
 316         for (TmfTraceElement trace : traceFolder.getTraces()) {
 317             if (trace.getName().equals(path.lastSegment())) {
 318                 doit = false;
 319                 break;
 320             }
 321         }
 322         if (doit) {
 323             importTrace(traceFolder.getResource(), path);
 324             return true;
 325         }
 326         return false;
 327     }
 328
 329     /**
 330      * Import a trace to the trace folder
 331      *
 332      * @param resource the trace folder resource
 333      * @param path the path to the trace to import
 334      */
 335     private void importTrace(IFolder resource, Path path) {
 336         IPath containerPath = resource.getFullPath();
 337         File file = new File(path.toString());
 338         File source = file.getParentFile();
 339         IOverwriteQuery overwriteImplementor = new IOverwriteQuery() {
 340             @Override
 341             public String queryOverwrite(String pathString) {
 342                 return IOverwriteQuery.NO_ALL;
 343             }
 344         };
 345         List<File> filesToImport = new LinkedList<File>();
 346         filesToImport.add(file);
 347         ImportOperation operation = new ImportOperation(
 348                 containerPath,
 349                 source,
 350                 FileSystemStructureProvider.INSTANCE,
 351                 overwriteImplementor,
 352                 filesToImport);
 353         operation.setCreateContainerStructure(false);
 354         try {
 355             operation.run(new NullProgressMonitor());
 356         } catch (InvocationTargetException e) {
 357             displayException(e);
 358         } catch (InterruptedException e) {
 359             displayException(e);
 360         }
 361     }
 362     /**
 363      * Create a link to the actual trace and set the trace type
 364      *
 365      * @param parentFolder the parent folder
 366      * @param resource the resource
 367      */
 368     private void createLink(IFolder parentFolder, IResource resource) {
 369         IPath location = resource.getLocation();
 370         IWorkspace workspace = ResourcesPlugin.getWorkspace();
 371         try {
 372             Map<QualifiedName, String> properties = resource.getPersistentProperties();
 373             String bundleName = properties.get(TmfTraceElement.TRACEBUNDLE);
 374             String traceType = properties.get(TmfTraceElement.TRACETYPE);
 375             String iconUrl = properties.get(TmfTraceElement.TRACEICON);
 376
 377             if (resource instanceof IFolder) {
 378                 IFolder folder = parentFolder.getFolder(resource.getName());
 379                 if (workspace.validateLinkLocation(folder, location).isOK()) {
 380                     folder.createLink(location, IResource.REPLACE, null);
 381                     setProperties(folder, bundleName, traceType, iconUrl);
 382
 383                 } else {
 384                     System.out.println("Invalid Trace Location"); //$NON-NLS-1$
 385                 }
 386             } else {
 387                 IFile file = parentFolder.getFile(resource.getName());
 388                 if (workspace.validateLinkLocation(file, location).isOK()) {
 389                     file.createLink(location, IResource.REPLACE, null);
 390                     setProperties(file, bundleName, traceType, iconUrl);
 391                 } else {
 392                     System.out.println("Invalid Trace Location"); //$NON-NLS-1$
 393                 }
 394             }
 395         } catch (CoreException e) {
 396             displayException(e);
 397         }
 398     }
 399
 400     /**
 401      * Set the trace persistent properties
 402      *
 403      * @param resource the trace resource
 404      * @param bundleName the bundle name
 405      * @param traceType the trace type
 406      * @param iconUrl the icon URL
 407      * @throws CoreException
 408      */
 409     private void setProperties(IResource resource, String bundleName, String traceType, String iconUrl) throws CoreException {
 410         resource.setPersistentProperty(TmfTraceElement.TRACEBUNDLE, bundleName);
 411         resource.setPersistentProperty(TmfTraceElement.TRACETYPE, traceType);
 412         resource.setPersistentProperty(TmfTraceElement.TRACEICON, iconUrl);
 413     }
 414
 415     /**
 416      * Display an exception in a message box
 417      *
 418      * @param e the exception
 419      */
 420     private void displayException(Exception e) {
 421         MessageBox mb = new MessageBox(PlatformUI.getWorkbench().getActiveWorkbenchWindow().getShell());
 422         mb.setText(e.getClass().getName());
 423         mb.setMessage(e.getMessage());
 424         mb.open();
 425     }
 426
 427 }