org.eclipse.linuxtools.tmf.ui/src/org/eclipse/linuxtools/tmf/ui/project/model/TmfTraceElement.java

   1 /*******************************************************************************
   2  * Copyright (c) 2010, 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  *   Bernd Hufmann - Added supplementary files handling
  12  *   Geneviève Bastien - Moved supplementary files handling to parent class,
  13  *                       added code to copy trace
  14  *   Patrick Tasse - Close editors to release resources
  15  *   Jean-Christian Kouame - added trace properties to be shown into
  16  *                           the properties view
  17  *   Geneviève Bastien - Moved trace type related methods to parent class
  18  *******************************************************************************/
  19
  20 package org.eclipse.linuxtools.tmf.ui.project.model;
  21
  22 import java.util.Arrays;
  23 import java.util.HashMap;
  24 import java.util.LinkedList;
  25 import java.util.List;
  26 import java.util.Map;
  27
  28 import org.eclipse.core.resources.IFile;
  29 import org.eclipse.core.resources.IFolder;
  30 import org.eclipse.core.resources.IResource;
  31 import org.eclipse.core.runtime.CoreException;
  32 import org.eclipse.core.runtime.IConfigurationElement;
  33 import org.eclipse.core.runtime.IPath;
  34 import org.eclipse.core.runtime.IProgressMonitor;
  35 import org.eclipse.core.runtime.Platform;
  36 import org.eclipse.core.runtime.URIUtil;
  37 import org.eclipse.linuxtools.internal.tmf.ui.Activator;
  38 import org.eclipse.linuxtools.tmf.core.TmfCommonConstants;
  39 import org.eclipse.linuxtools.tmf.core.event.ITmfEvent;
  40 import org.eclipse.linuxtools.tmf.core.parsers.custom.CustomTxtEvent;
  41 import org.eclipse.linuxtools.tmf.core.parsers.custom.CustomTxtTrace;
  42 import org.eclipse.linuxtools.tmf.core.parsers.custom.CustomTxtTraceDefinition;
  43 import org.eclipse.linuxtools.tmf.core.parsers.custom.CustomXmlEvent;
  44 import org.eclipse.linuxtools.tmf.core.parsers.custom.CustomXmlTrace;
  45 import org.eclipse.linuxtools.tmf.core.parsers.custom.CustomXmlTraceDefinition;
  46 import org.eclipse.linuxtools.tmf.core.project.model.TmfTraceType;
  47 import org.eclipse.linuxtools.tmf.core.trace.ITmfTrace;
  48 import org.eclipse.linuxtools.tmf.core.trace.ITmfTraceProperties;
  49 import org.eclipse.linuxtools.tmf.core.trace.TmfTrace;
  50 import org.eclipse.linuxtools.tmf.core.trace.TmfTraceManager;
  51 import org.eclipse.linuxtools.tmf.ui.editors.TmfEventsEditor;
  52 import org.eclipse.linuxtools.tmf.ui.properties.ReadOnlyTextPropertyDescriptor;
  53 import org.eclipse.ui.IActionFilter;
  54 import org.eclipse.ui.views.properties.IPropertyDescriptor;
  55 import org.eclipse.ui.views.properties.IPropertySource2;
  56
  57 /**
  58  * Implementation of trace model element representing a trace. It provides
  59  * methods to instantiate <code>ITmfTrace</code> and <code>ITmfEvent</code> as
  60  * well as editor ID from the trace type extension definition.
  61  *
  62  * @version 1.0
  63  * @author Francois Chouinard
  64  */
  65 public class TmfTraceElement extends TmfCommonProjectElement implements IActionFilter, IPropertySource2 {
  66
  67     // ------------------------------------------------------------------------
  68     // Constants
  69     // ------------------------------------------------------------------------
  70
  71     // Other attributes
  72     /**
  73      * Bundle attribute name
  74      */
  75     public static final String BUNDLE = "bundle"; //$NON-NLS-1$
  76     /**
  77      * IsLinked attribute name.
  78      */
  79     public static final String IS_LINKED = "isLinked"; //$NON-NLS-1$
  80
  81     // Property View stuff
  82     private static final String sfResourcePropertiesCategory = Messages.TmfTraceElement_ResourceProperties;
  83     private static final String sfName = Messages.TmfTraceElement_Name;
  84     private static final String sfPath = Messages.TmfTraceElement_Path;
  85     private static final String sfLocation = Messages.TmfTraceElement_Location;
  86     private static final String sfEventType = Messages.TmfTraceElement_EventType;
  87     private static final String sfIsLinked = Messages.TmfTraceElement_IsLinked;
  88     private static final String sfSourceLocation = Messages.TmfTraceElement_SourceLocation;
  89     private static final String sfTracePropertiesCategory = Messages.TmfTraceElement_TraceProperties;
  90
  91     private static final ReadOnlyTextPropertyDescriptor sfNameDescriptor = new ReadOnlyTextPropertyDescriptor(sfName, sfName);
  92     private static final ReadOnlyTextPropertyDescriptor sfPathDescriptor = new ReadOnlyTextPropertyDescriptor(sfPath, sfPath);
  93     private static final ReadOnlyTextPropertyDescriptor sfLocationDescriptor = new ReadOnlyTextPropertyDescriptor(sfLocation, sfLocation);
  94     private static final ReadOnlyTextPropertyDescriptor sfTypeDescriptor = new ReadOnlyTextPropertyDescriptor(sfEventType, sfEventType);
  95     private static final ReadOnlyTextPropertyDescriptor sfIsLinkedDescriptor = new ReadOnlyTextPropertyDescriptor(sfIsLinked, sfIsLinked);
  96     private static final ReadOnlyTextPropertyDescriptor sfSourceLocationDescriptor = new ReadOnlyTextPropertyDescriptor(sfSourceLocation, sfSourceLocation);
  97
  98     private static final IPropertyDescriptor[] sfDescriptors = { sfNameDescriptor, sfPathDescriptor, sfLocationDescriptor,
  99             sfTypeDescriptor, sfIsLinkedDescriptor, sfSourceLocationDescriptor };
 100
 101     static {
 102         sfNameDescriptor.setCategory(sfResourcePropertiesCategory);
 103         sfPathDescriptor.setCategory(sfResourcePropertiesCategory);
 104         sfLocationDescriptor.setCategory(sfResourcePropertiesCategory);
 105         sfTypeDescriptor.setCategory(sfResourcePropertiesCategory);
 106         sfIsLinkedDescriptor.setCategory(sfResourcePropertiesCategory);
 107         sfSourceLocationDescriptor.setCategory(sfResourcePropertiesCategory);
 108     }
 109
 110     // ------------------------------------------------------------------------
 111     // Static initialization
 112     // ------------------------------------------------------------------------
 113
 114     // The mapping of available trace type IDs to their corresponding
 115     // configuration element
 116     private static final Map<String, IConfigurationElement> sfTraceTypeAttributes = new HashMap<>();
 117     private static final Map<String, IConfigurationElement> sfTraceTypeUIAttributes = new HashMap<>();
 118     private static final Map<String, IConfigurationElement> sfTraceCategories = new HashMap<>();
 119
 120     /**
 121      * Initialize statically at startup by getting extensions from the platform
 122      * extension registry.
 123      */
 124     public static void init() {
 125         /* Read the tmf.core "tracetype" extension point */
 126         IConfigurationElement[] config = Platform.getExtensionRegistry().getConfigurationElementsFor(TmfTraceType.TMF_TRACE_TYPE_ID);
 127         for (IConfigurationElement ce : config) {
 128             switch (ce.getName()) {
 129             case TmfTraceType.TYPE_ELEM:
 130                 String traceTypeId = ce.getAttribute(TmfTraceType.ID_ATTR);
 131                 sfTraceTypeAttributes.put(traceTypeId, ce);
 132                 break;
 133             case TmfTraceType.CATEGORY_ELEM:
 134                 String categoryId = ce.getAttribute(TmfTraceType.ID_ATTR);
 135                 sfTraceCategories.put(categoryId, ce);
 136                 break;
 137             default:
 138             }
 139         }
 140
 141         /*
 142          * Read the corresponding tmf.ui "tracetypeui" extension point for this
 143          * trace type, if it exists.
 144          */
 145         config = Platform.getExtensionRegistry().getConfigurationElementsFor(TmfTraceTypeUIUtils.TMF_TRACE_TYPE_UI_ID);
 146         for (IConfigurationElement ce : config) {
 147             String elemName = ce.getName();
 148             if (TmfTraceTypeUIUtils.TYPE_ELEM.equals(elemName)) {
 149                 String traceType = ce.getAttribute(TmfTraceTypeUIUtils.TRACETYPE_ATTR);
 150                 sfTraceTypeUIAttributes.put(traceType, ce);
 151             }
 152         }
 153     }
 154
 155     // ------------------------------------------------------------------------
 156     // Constructors
 157     // ------------------------------------------------------------------------
 158     /**
 159      * Constructor. Creates trace model element under the trace folder.
 160      *
 161      * @param name
 162      *            The name of trace
 163      * @param trace
 164      *            The trace resource.
 165      * @param parent
 166      *            The parent element (trace folder)
 167      */
 168     public TmfTraceElement(String name, IResource trace, TmfTraceFolder parent) {
 169         super(name, trace, parent);
 170     }
 171
 172     /**
 173      * Constructor. Creates trace model element under the experiment folder.
 174      *
 175      * @param name
 176      *            The name of trace
 177      * @param trace
 178      *            The trace resource.
 179      * @param parent
 180      *            The parent element (experiment folder)
 181      */
 182     public TmfTraceElement(String name, IResource trace, TmfExperimentElement parent) {
 183         super(name, trace, parent);
 184     }
 185
 186     // ------------------------------------------------------------------------
 187     // Operations
 188     // ------------------------------------------------------------------------
 189
 190     /**
 191      * Instantiate a <code>ITmfTrace</code> object based on the trace type and
 192      * the corresponding extension.
 193      *
 194      * @return the <code>ITmfTrace</code> or <code>null</code> for an error
 195      */
 196     @Override
 197     public ITmfTrace instantiateTrace() {
 198         try {
 199
 200             // make sure that supplementary folder exists
 201             refreshSupplementaryFolder();
 202
 203             if (getTraceType() != null) {
 204                 if (getTraceType().startsWith(CustomTxtTrace.class.getCanonicalName())) {
 205                     for (CustomTxtTraceDefinition def : CustomTxtTraceDefinition.loadAll()) {
 206                         if (getTraceType().equals(CustomTxtTrace.class.getCanonicalName() + ":" + def.definitionName)) { //$NON-NLS-1$
 207                             return new CustomTxtTrace(def);
 208                         }
 209                     }
 210                 }
 211                 if (getTraceType().startsWith(CustomXmlTrace.class.getCanonicalName())) {
 212                     for (CustomXmlTraceDefinition def : CustomXmlTraceDefinition.loadAll()) {
 213                         if (getTraceType().equals(CustomXmlTrace.class.getCanonicalName() + ":" + def.definitionName)) { //$NON-NLS-1$
 214                             return new CustomXmlTrace(def);
 215                         }
 216                     }
 217                 }
 218                 IConfigurationElement ce = sfTraceTypeAttributes.get(getTraceType());
 219                 if (ce == null) {
 220                     return null;
 221                 }
 222                 ITmfTrace trace = (ITmfTrace) ce.createExecutableExtension(TmfTraceType.TRACE_TYPE_ATTR);
 223                 return trace;
 224             }
 225         } catch (CoreException e) {
 226             Activator.getDefault().logError("Error instantiating ITmfTrace object for trace " + getName(), e); //$NON-NLS-1$
 227         }
 228         return null;
 229     }
 230
 231     /**
 232      * Instantiate a <code>ITmfEvent</code> object based on the trace type and
 233      * the corresponding extension.
 234      *
 235      * @return the <code>ITmfEvent</code> or <code>null</code> for an error
 236      */
 237     public ITmfEvent instantiateEvent() {
 238         try {
 239             if (getTraceType() != null) {
 240                 if (getTraceType().startsWith(CustomTxtTrace.class.getCanonicalName())) {
 241                     for (CustomTxtTraceDefinition def : CustomTxtTraceDefinition.loadAll()) {
 242                         if (getTraceType().equals(CustomTxtTrace.class.getCanonicalName() + ":" + def.definitionName)) { //$NON-NLS-1$
 243                             return new CustomTxtEvent(def);
 244                         }
 245                     }
 246                 }
 247                 if (getTraceType().startsWith(CustomXmlTrace.class.getCanonicalName())) {
 248                     for (CustomXmlTraceDefinition def : CustomXmlTraceDefinition.loadAll()) {
 249                         if (getTraceType().equals(CustomXmlTrace.class.getCanonicalName() + ":" + def.definitionName)) { //$NON-NLS-1$
 250                             return new CustomXmlEvent(def);
 251                         }
 252                     }
 253                 }
 254                 IConfigurationElement ce = sfTraceTypeAttributes.get(getTraceType());
 255                 if (ce == null) {
 256                     return null;
 257                 }
 258                 ITmfEvent event = (ITmfEvent) ce.createExecutableExtension(TmfTraceType.EVENT_TYPE_ATTR);
 259                 return event;
 260             }
 261         } catch (CoreException e) {
 262             Activator.getDefault().logError("Error instantiating ITmfEvent object for trace " + getName(), e); //$NON-NLS-1$
 263         }
 264         return null;
 265     }
 266
 267     @Override
 268     public String getEditorId() {
 269         if (getTraceType() != null) {
 270             if (getTraceType().startsWith(CustomTxtTrace.class.getCanonicalName())) {
 271                 return TmfEventsEditor.ID;
 272             }
 273             if (getTraceType().startsWith(CustomXmlTrace.class.getCanonicalName())) {
 274                 return TmfEventsEditor.ID;
 275             }
 276             IConfigurationElement ce = sfTraceTypeUIAttributes.get(getTraceType());
 277             if (ce == null) {
 278                 /* This trace type does not define UI attributes */
 279                 return null;
 280             }
 281             IConfigurationElement[] defaultEditorCE = ce.getChildren(TmfTraceTypeUIUtils.DEFAULT_EDITOR_ELEM);
 282             if (defaultEditorCE.length == 1) {
 283                 return defaultEditorCE[0].getAttribute(TmfTraceType.ID_ATTR);
 284             }
 285         }
 286         return null;
 287     }
 288
 289     /**
 290      * Returns the file resource used to store bookmarks after creating it if
 291      * necessary. If the trace resource is a file, it is returned directly. If
 292      * the trace resource is a folder, a linked file is returned. The file will
 293      * be created if it does not exist.
 294      *
 295      * @return the bookmarks file
 296      * @throws CoreException
 297      *             if the bookmarks file cannot be created
 298      * @since 2.0
 299      */
 300     @Override
 301     public IFile createBookmarksFile() throws CoreException {
 302         IFile file = getBookmarksFile();
 303         if (fResource instanceof IFolder) {
 304             return createBookmarksFile(getProject().getTracesFolder().getResource(), TmfTrace.class.getCanonicalName());
 305         }
 306         return file;
 307     }
 308
 309     /**
 310      * Returns the file resource used to store bookmarks. The file may not
 311      * exist.
 312      *
 313      * @return the bookmarks file
 314      * @since 2.0
 315      */
 316     @Override
 317     public IFile getBookmarksFile() {
 318         IFile file = null;
 319         if (fResource instanceof IFile) {
 320             file = (IFile) fResource;
 321         } else if (fResource instanceof IFolder) {
 322             final IFolder folder = (IFolder) fResource;
 323             file = folder.getFile(getName() + '_');
 324         }
 325         return file;
 326     }
 327
 328     /**
 329      * Returns the <code>TmfTraceElement</code> located under the
 330      * <code>TmfTracesFolder</code>.
 331      *
 332      * @return <code>this</code> if this element is under the
 333      *         <code>TmfTracesFolder</code> else the corresponding
 334      *         <code>TmfTraceElement</code> if this element is under
 335      *         <code>TmfExperimentElement</code>.
 336      */
 337     public TmfTraceElement getElementUnderTraceFolder() {
 338
 339         // If trace is under an experiment, return original trace from the
 340         // traces folder
 341         if (getParent() instanceof TmfExperimentElement) {
 342             for (TmfTraceElement aTrace : getProject().getTracesFolder().getTraces()) {
 343                 if (aTrace.getElementPath().equals(getElementPath())) {
 344                     return aTrace;
 345                 }
 346             }
 347         }
 348         return this;
 349     }
 350
 351     @Override
 352     public String getTypeName() {
 353         return Messages.TmfTraceElement_TypeName;
 354     }
 355
 356     // ------------------------------------------------------------------------
 357     // IActionFilter
 358     // ------------------------------------------------------------------------
 359
 360     @Override
 361     public boolean testAttribute(Object target, String name, String value) {
 362         if (name.equals(IS_LINKED)) {
 363             boolean isLinked = getResource().isLinked();
 364             return Boolean.toString(isLinked).equals(value);
 365         }
 366         return false;
 367     }
 368
 369     // ------------------------------------------------------------------------
 370     // IPropertySource2
 371     // ------------------------------------------------------------------------
 372
 373     @Override
 374     public Object getEditableValue() {
 375         return null;
 376     }
 377
 378     /**
 379      * Get the trace properties of this traceElement if the corresponding trace
 380      * is opened in an editor
 381      *
 382      * @return a map with the names and values of the trace properties
 383      *         respectively as keys and values
 384      */
 385     private Map<String, String> getTraceProperties() {
 386         for (ITmfTrace openedTrace : TmfTraceManager.getInstance().getOpenedTraces()) {
 387             for (ITmfTrace singleTrace : TmfTraceManager.getTraceSet(openedTrace)) {
 388                 if (this.getLocation().getPath().endsWith(singleTrace.getPath())) {
 389                     if (singleTrace instanceof ITmfTraceProperties) {
 390                         ITmfTraceProperties traceProperties = (ITmfTraceProperties) singleTrace;
 391                         return traceProperties.getTraceProperties();
 392                     }
 393                 }
 394             }
 395         }
 396         return new HashMap<>();
 397     }
 398
 399     @Override
 400     public IPropertyDescriptor[] getPropertyDescriptors() {
 401         Map<String, String> traceProperties = getTraceProperties();
 402         if (!traceProperties.isEmpty()) {
 403             IPropertyDescriptor[] propertyDescriptorArray = new IPropertyDescriptor[traceProperties.size() + sfDescriptors.length];
 404             int index = 0;
 405             for (Map.Entry<String, String> varName : traceProperties.entrySet()) {
 406                 ReadOnlyTextPropertyDescriptor descriptor = new ReadOnlyTextPropertyDescriptor(this.getName() + "_" + varName.getKey(), varName.getKey()); //$NON-NLS-1$
 407                 descriptor.setCategory(sfTracePropertiesCategory);
 408                 propertyDescriptorArray[index] = descriptor;
 409                 index++;
 410             }
 411             for (int i = 0; i < sfDescriptors.length; i++) {
 412                 propertyDescriptorArray[index] = sfDescriptors[i];
 413                 index++;
 414             }
 415             return propertyDescriptorArray;
 416         }
 417         return Arrays.copyOf(sfDescriptors, sfDescriptors.length);
 418     }
 419
 420     @Override
 421     public Object getPropertyValue(Object id) {
 422
 423         if (sfName.equals(id)) {
 424             return getName();
 425         }
 426
 427         if (sfPath.equals(id)) {
 428             return getPath().toString();
 429         }
 430
 431         if (sfLocation.equals(id)) {
 432             return URIUtil.toUnencodedString(getLocation());
 433         }
 434
 435         if (sfIsLinked.equals(id)) {
 436             return Boolean.valueOf(getResource().isLinked()).toString();
 437         }
 438
 439         if (sfSourceLocation.equals(id)) {
 440             try {
 441                 String sourceLocation = getElementUnderTraceFolder().getResource().getPersistentProperty(TmfCommonConstants.SOURCE_LOCATION);
 442                 if (sourceLocation != null) {
 443                     return sourceLocation;
 444                 }
 445             } catch (CoreException e) {
 446             }
 447             return ""; //$NON-NLS-1$
 448         }
 449
 450         if (sfEventType.equals(id)) {
 451             if (getTraceType() != null) {
 452                 IConfigurationElement ce = sfTraceTypeAttributes.get(getTraceType());
 453                 return (ce != null) ? (getCategory(ce) + " : " + ce.getAttribute(TmfTraceType.NAME_ATTR)) : ""; //$NON-NLS-1$ //$NON-NLS-2$
 454             }
 455             return ""; //$NON-NLS-1$
 456         }
 457
 458         Map<String, String> traceProperties = getTraceProperties();
 459         if (id != null && !traceProperties.isEmpty()) {
 460             String key = (String) id;
 461             key = key.substring(this.getName().length() + 1); // remove name_
 462             String value = traceProperties.get(key);
 463             return value;
 464         }
 465
 466         return null;
 467     }
 468
 469     private static String getCategory(IConfigurationElement ce) {
 470         String categoryId = ce.getAttribute(TmfTraceType.CATEGORY_ATTR);
 471         if (categoryId != null) {
 472             IConfigurationElement category = sfTraceCategories.get(categoryId);
 473             if (category != null) {
 474                 return category.getAttribute(TmfTraceType.NAME_ATTR);
 475             }
 476         }
 477         return "[no category]"; //$NON-NLS-1$
 478     }
 479
 480     @Override
 481     public void resetPropertyValue(Object id) {
 482     }
 483
 484     @Override
 485     public void setPropertyValue(Object id, Object value) {
 486     }
 487
 488     @Override
 489     public boolean isPropertyResettable(Object id) {
 490         return false;
 491     }
 492
 493     @Override
 494     public boolean isPropertySet(Object id) {
 495         return false;
 496     }
 497
 498     /**
 499      * Copy this trace in the trace folder. No other parameters are mentioned so
 500      * the trace is copied in this element's project trace folder
 501      *
 502      * @param string
 503      *            The new trace name
 504      * @return the new Resource object
 505      * @since 2.0
 506      */
 507     public TmfTraceElement copy(String string) {
 508         TmfTraceFolder folder = this.getProject().getTracesFolder();
 509         IResource res = super.copy(string, false);
 510         return new TmfTraceElement(string, res, folder);
 511     }
 512
 513     /**
 514      * Close opened editors associated with this trace.
 515      *
 516      * @since 2.0
 517      */
 518     @Override
 519     public void closeEditors() {
 520         super.closeEditors();
 521
 522         // Close experiments that contain the trace if open
 523         if (getParent() instanceof TmfTraceFolder) {
 524             TmfExperimentFolder experimentsFolder = getProject().getExperimentsFolder();
 525             for (TmfExperimentElement experiment : experimentsFolder.getExperiments()) {
 526                 for (TmfTraceElement trace : experiment.getTraces()) {
 527                     if (trace.getElementPath().equals(getElementPath())) {
 528                         experiment.closeEditors();
 529                         break;
 530                     }
 531                 }
 532             }
 533         } else if (getParent() instanceof TmfExperimentElement) {
 534             TmfExperimentElement experiment = (TmfExperimentElement) getParent();
 535             experiment.closeEditors();
 536         }
 537
 538         /*
 539          * We will be closing a trace shortly. Invoke GC to release
 540          * MappedByteBuffer objects, which some trace types, like CTF, use.
 541          * (see Java bug JDK-4724038)
 542          */
 543         System.gc();
 544     }
 545
 546     /**
 547      * Delete the trace resource, remove it from experiments and delete its
 548      * supplementary files
 549      *
 550      * @param progressMonitor
 551      *            a progress monitor, or null if progress reporting is not
 552      *            desired
 553      *
 554      * @throws CoreException
 555      *             thrown when IResource.delete fails
 556      * @since 2.2
 557      */
 558     public void delete(IProgressMonitor progressMonitor) throws CoreException {
 559         closeEditors();
 560
 561         IPath path = fResource.getLocation();
 562         if (path != null) {
 563             if (getParent() instanceof TmfTraceFolder) {
 564                 TmfExperimentFolder experimentFolder = getProject().getExperimentsFolder();
 565
 566                 // Propagate the removal to traces
 567                 for (TmfExperimentElement experiment : experimentFolder.getExperiments()) {
 568                     List<TmfTraceElement> toRemove = new LinkedList<>();
 569                     for (TmfTraceElement trace : experiment.getTraces()) {
 570                         if (trace.getElementPath().equals(getElementPath())) {
 571                             toRemove.add(trace);
 572                         }
 573                     }
 574                     for (TmfTraceElement child : toRemove) {
 575                         experiment.removeTrace(child);
 576                     }
 577                 }
 578
 579                 // Delete supplementary files
 580                 deleteSupplementaryFolder();
 581
 582             } else if (getParent() instanceof TmfExperimentElement) {
 583                 TmfExperimentElement experimentElement = (TmfExperimentElement) getParent();
 584                 experimentElement.removeTrace(this);
 585             }
 586         }
 587
 588         // Finally, delete the trace
 589         fResource.delete(true, progressMonitor);
 590     }
 591
 592 }