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

   1 /*******************************************************************************
   2  * Copyright (c) 2010, 2015 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.tracecompass.tmf.ui.project.model;
  21
  22 import java.util.Arrays;
  23 import java.util.Date;
  24 import java.util.HashMap;
  25 import java.util.LinkedList;
  26 import java.util.List;
  27 import java.util.Map;
  28
  29 import org.eclipse.core.filesystem.EFS;
  30 import org.eclipse.core.filesystem.IFileInfo;
  31 import org.eclipse.core.resources.IFile;
  32 import org.eclipse.core.resources.IFolder;
  33 import org.eclipse.core.resources.IResource;
  34 import org.eclipse.core.runtime.CoreException;
  35 import org.eclipse.core.runtime.IConfigurationElement;
  36 import org.eclipse.core.runtime.IPath;
  37 import org.eclipse.core.runtime.IProgressMonitor;
  38 import org.eclipse.core.runtime.Platform;
  39 import org.eclipse.core.runtime.URIUtil;
  40 import org.eclipse.osgi.util.NLS;
  41 import org.eclipse.swt.widgets.Display;
  42 import org.eclipse.tracecompass.internal.tmf.ui.Activator;
  43 import org.eclipse.tracecompass.internal.tmf.ui.editors.ITmfEventsEditorConstants;
  44 import org.eclipse.tracecompass.tmf.core.TmfCommonConstants;
  45 import org.eclipse.tracecompass.tmf.core.event.ITmfEvent;
  46 import org.eclipse.tracecompass.tmf.core.parsers.custom.CustomTxtEvent;
  47 import org.eclipse.tracecompass.tmf.core.parsers.custom.CustomTxtTrace;
  48 import org.eclipse.tracecompass.tmf.core.parsers.custom.CustomTxtTraceDefinition;
  49 import org.eclipse.tracecompass.tmf.core.parsers.custom.CustomXmlEvent;
  50 import org.eclipse.tracecompass.tmf.core.parsers.custom.CustomXmlTrace;
  51 import org.eclipse.tracecompass.tmf.core.parsers.custom.CustomXmlTraceDefinition;
  52 import org.eclipse.tracecompass.tmf.core.project.model.ITmfPropertiesProvider;
  53 import org.eclipse.tracecompass.tmf.core.project.model.TmfTraceType;
  54 import org.eclipse.tracecompass.tmf.core.project.model.TraceTypeHelper;
  55 import org.eclipse.tracecompass.tmf.core.synchronization.TimestampTransformFactory;
  56 import org.eclipse.tracecompass.tmf.core.timestamp.TmfTimestampFormat;
  57 import org.eclipse.tracecompass.tmf.core.trace.ITmfTrace;
  58 import org.eclipse.tracecompass.tmf.core.trace.TmfTraceManager;
  59 import org.eclipse.tracecompass.tmf.ui.editors.TmfEventsEditor;
  60 import org.eclipse.tracecompass.tmf.ui.properties.ReadOnlyTextPropertyDescriptor;
  61 import org.eclipse.ui.IActionFilter;
  62 import org.eclipse.ui.views.properties.IPropertyDescriptor;
  63 import org.eclipse.ui.views.properties.IPropertySource2;
  64
  65 import com.ibm.icu.text.DateFormat;
  66 import com.ibm.icu.text.NumberFormat;
  67
  68 /**
  69  * Implementation of trace model element representing a trace. It provides
  70  * methods to instantiate <code>ITmfTrace</code> and <code>ITmfEvent</code> as
  71  * well as editor ID from the trace type extension definition.
  72  *
  73  * @version 1.0
  74  * @author Francois Chouinard
  75  */
  76 public class TmfTraceElement extends TmfCommonProjectElement implements IActionFilter, IPropertySource2 {
  77
  78     // ------------------------------------------------------------------------
  79     // Constants
  80     // ------------------------------------------------------------------------
  81
  82     // Other attributes
  83     /**
  84      * Bundle attribute name
  85      */
  86     public static final String BUNDLE = "bundle"; //$NON-NLS-1$
  87     /**
  88      * IsLinked attribute name.
  89      */
  90     public static final String IS_LINKED = "isLinked"; //$NON-NLS-1$
  91
  92     // Property View stuff
  93     private static final String RESOURCE_PROPERTIES_CATEGORY = Messages.TmfTraceElement_ResourceProperties;
  94     private static final String NAME = Messages.TmfTraceElement_Name;
  95     private static final String PATH = Messages.TmfTraceElement_Path;
  96     private static final String LOCATION = Messages.TmfTraceElement_Location;
  97     private static final String TRACE_TYPE = Messages.TmfTraceElement_EventType;
  98     private static final String IS_LINKED_PROPERTY = Messages.TmfTraceElement_IsLinked;
  99     private static final String SOURCE_LOCATION = Messages.TmfTraceElement_SourceLocation;
 100     private static final String TIME_OFFSET = Messages.TmfTraceElement_TimeOffset;
 101     private static final String LAST_MODIFIED = Messages.TmfTraceElement_LastModified;
 102     private static final String SIZE = Messages.TmfTraceElement_Size;
 103     private static final String TRACE_PROPERTIES_CATEGORY = Messages.TmfTraceElement_TraceProperties;
 104
 105     private static final ReadOnlyTextPropertyDescriptor NAME_DESCRIPTOR = new ReadOnlyTextPropertyDescriptor(NAME, NAME);
 106     private static final ReadOnlyTextPropertyDescriptor PATH_DESCRIPTOR = new ReadOnlyTextPropertyDescriptor(PATH, PATH);
 107     private static final ReadOnlyTextPropertyDescriptor LOCATION_DESCRIPTOR = new ReadOnlyTextPropertyDescriptor(LOCATION, LOCATION);
 108     private static final ReadOnlyTextPropertyDescriptor TYPE_DESCRIPTOR = new ReadOnlyTextPropertyDescriptor(TRACE_TYPE, TRACE_TYPE);
 109     private static final ReadOnlyTextPropertyDescriptor IS_LINKED_DESCRIPTOR = new ReadOnlyTextPropertyDescriptor(IS_LINKED_PROPERTY, IS_LINKED_PROPERTY);
 110     private static final ReadOnlyTextPropertyDescriptor SOURCE_LOCATION_DESCRIPTOR = new ReadOnlyTextPropertyDescriptor(SOURCE_LOCATION, SOURCE_LOCATION);
 111     private static final ReadOnlyTextPropertyDescriptor TIME_OFFSET_DESCRIPTOR = new ReadOnlyTextPropertyDescriptor(TIME_OFFSET, TIME_OFFSET);
 112     private static final ReadOnlyTextPropertyDescriptor LAST_MODIFIED_DESCRIPTOR = new ReadOnlyTextPropertyDescriptor(LAST_MODIFIED, LAST_MODIFIED);
 113     private static final ReadOnlyTextPropertyDescriptor SIZE_DESCRIPTOR = new ReadOnlyTextPropertyDescriptor(SIZE, SIZE);
 114
 115     private static final IPropertyDescriptor[] sfDescriptors = { NAME_DESCRIPTOR, PATH_DESCRIPTOR, LOCATION_DESCRIPTOR,
 116             TYPE_DESCRIPTOR, IS_LINKED_DESCRIPTOR, SOURCE_LOCATION_DESCRIPTOR,
 117             TIME_OFFSET_DESCRIPTOR, LAST_MODIFIED_DESCRIPTOR, SIZE_DESCRIPTOR };
 118
 119     static {
 120         NAME_DESCRIPTOR.setCategory(RESOURCE_PROPERTIES_CATEGORY);
 121         PATH_DESCRIPTOR.setCategory(RESOURCE_PROPERTIES_CATEGORY);
 122         LOCATION_DESCRIPTOR.setCategory(RESOURCE_PROPERTIES_CATEGORY);
 123         TYPE_DESCRIPTOR.setCategory(RESOURCE_PROPERTIES_CATEGORY);
 124         IS_LINKED_DESCRIPTOR.setCategory(RESOURCE_PROPERTIES_CATEGORY);
 125         SOURCE_LOCATION_DESCRIPTOR.setCategory(RESOURCE_PROPERTIES_CATEGORY);
 126         TIME_OFFSET_DESCRIPTOR.setCategory(RESOURCE_PROPERTIES_CATEGORY);
 127         LAST_MODIFIED_DESCRIPTOR.setCategory(RESOURCE_PROPERTIES_CATEGORY);
 128         SIZE_DESCRIPTOR.setCategory(RESOURCE_PROPERTIES_CATEGORY);
 129     }
 130
 131     private static final TmfTimestampFormat OFFSET_FORMAT = new TmfTimestampFormat("T.SSS SSS SSS s"); //$NON-NLS-1$
 132
 133     private static final int FOLDER_MAX_COUNT = 1024;
 134
 135     // ------------------------------------------------------------------------
 136     // Static initialization
 137     // ------------------------------------------------------------------------
 138
 139     // The mapping of available trace type IDs to their corresponding
 140     // configuration element
 141     private static final Map<String, IConfigurationElement> TRACE_TYPE_ATTRIBUTES = new HashMap<>();
 142     private static final Map<String, IConfigurationElement> TRACE_TYPE_UI_ATTRIBUTES = new HashMap<>();
 143     private static final Map<String, IConfigurationElement> TRACE_CATEGORIES = new HashMap<>();
 144
 145     /**
 146      * Initialize statically at startup by getting extensions from the platform
 147      * extension registry.
 148      */
 149     public static void init() {
 150         /* Read the tmf.core "tracetype" extension point */
 151         IConfigurationElement[] config = Platform.getExtensionRegistry().getConfigurationElementsFor(TmfTraceType.TMF_TRACE_TYPE_ID);
 152         for (IConfigurationElement ce : config) {
 153             switch (ce.getName()) {
 154             case TmfTraceType.TYPE_ELEM:
 155                 String traceTypeId = ce.getAttribute(TmfTraceType.ID_ATTR);
 156                 TRACE_TYPE_ATTRIBUTES.put(traceTypeId, ce);
 157                 break;
 158             case TmfTraceType.CATEGORY_ELEM:
 159                 String categoryId = ce.getAttribute(TmfTraceType.ID_ATTR);
 160                 TRACE_CATEGORIES.put(categoryId, ce);
 161                 break;
 162             default:
 163             }
 164         }
 165
 166         /*
 167          * Read the corresponding tmf.ui "tracetypeui" extension point for this
 168          * trace type, if it exists.
 169          */
 170         config = Platform.getExtensionRegistry().getConfigurationElementsFor(TmfTraceTypeUIUtils.TMF_TRACE_TYPE_UI_ID);
 171         for (IConfigurationElement ce : config) {
 172             String elemName = ce.getName();
 173             if (TmfTraceTypeUIUtils.TYPE_ELEM.equals(elemName)) {
 174                 String traceType = ce.getAttribute(TmfTraceTypeUIUtils.TRACETYPE_ATTR);
 175                 TRACE_TYPE_UI_ATTRIBUTES.put(traceType, ce);
 176             }
 177         }
 178     }
 179
 180     // ------------------------------------------------------------------------
 181     // Classes
 182     // ------------------------------------------------------------------------
 183
 184     private class FileInfo {
 185         long lastModified;
 186         long size;
 187         int count;
 188     }
 189
 190     // ------------------------------------------------------------------------
 191     // Attributes
 192     // ------------------------------------------------------------------------
 193
 194     private FileInfo fFileInfo;
 195
 196     // ------------------------------------------------------------------------
 197     // Constructors
 198     // ------------------------------------------------------------------------
 199     /**
 200      * Constructor. Creates trace model element under the trace folder.
 201      *
 202      * @param name
 203      *            The name of trace
 204      * @param trace
 205      *            The trace resource.
 206      * @param parent
 207      *            The parent element (trace folder)
 208      */
 209     public TmfTraceElement(String name, IResource trace, TmfTraceFolder parent) {
 210         super(name, trace, parent);
 211     }
 212
 213     /**
 214      * Constructor. Creates trace model element under the experiment folder.
 215      *
 216      * @param name
 217      *            The name of trace
 218      * @param trace
 219      *            The trace resource.
 220      * @param parent
 221      *            The parent element (experiment folder)
 222      */
 223     public TmfTraceElement(String name, IResource trace, TmfExperimentElement parent) {
 224         super(name, trace, parent);
 225     }
 226
 227     // ------------------------------------------------------------------------
 228     // Operations
 229     // ------------------------------------------------------------------------
 230
 231     /**
 232      * Instantiate a <code>ITmfTrace</code> object based on the trace type and
 233      * the corresponding extension.
 234      *
 235      * @return the <code>ITmfTrace</code> or <code>null</code> for an error
 236      */
 237     @Override
 238     public ITmfTrace instantiateTrace() {
 239         try {
 240
 241             // make sure that supplementary folder exists
 242             refreshSupplementaryFolder();
 243
 244             String traceTypeId = getTraceType();
 245             if (traceTypeId != null) {
 246                 if (CustomTxtTrace.isCustomTraceTypeId(traceTypeId)) {
 247                     for (CustomTxtTraceDefinition def : CustomTxtTraceDefinition.loadAll()) {
 248                         String id = CustomTxtTrace.buildTraceTypeId(def.categoryName, def.definitionName);
 249                         if (traceTypeId.equals(id)) {
 250                             return new CustomTxtTrace(def);
 251                         }
 252                     }
 253                 }
 254                 if (CustomXmlTrace.isCustomTraceTypeId(traceTypeId)) {
 255                     for (CustomXmlTraceDefinition def : CustomXmlTraceDefinition.loadAll()) {
 256                         String id = CustomXmlTrace.buildTraceTypeId(def.categoryName, def.definitionName);
 257                         if (traceTypeId.equals(id)) {
 258                             return new CustomXmlTrace(def);
 259                         }
 260                     }
 261                 }
 262                 IConfigurationElement ce = TRACE_TYPE_ATTRIBUTES.get(traceTypeId);
 263                 if (ce == null) {
 264                     return null;
 265                 }
 266                 ITmfTrace trace = (ITmfTrace) ce.createExecutableExtension(TmfTraceType.TRACE_TYPE_ATTR);
 267                 return trace;
 268             }
 269         } catch (CoreException e) {
 270             Activator.getDefault().logError("Error instantiating ITmfTrace object for trace " + getName(), e); //$NON-NLS-1$
 271         }
 272         return null;
 273     }
 274
 275     /**
 276      * Instantiate a <code>ITmfEvent</code> object based on the trace type and
 277      * the corresponding extension.
 278      *
 279      * @return the <code>ITmfEvent</code> or <code>null</code> for an error
 280      */
 281     public ITmfEvent instantiateEvent() {
 282         try {
 283             String traceTypeId = getTraceType();
 284             if (traceTypeId != null) {
 285                 if (CustomTxtTrace.isCustomTraceTypeId(traceTypeId)) {
 286                     for (CustomTxtTraceDefinition def : CustomTxtTraceDefinition.loadAll()) {
 287                         String id = CustomTxtTrace.buildTraceTypeId(def.categoryName, def.definitionName);
 288                         if (traceTypeId.equals(id)) {
 289                             return new CustomTxtEvent(def);
 290                         }
 291                     }
 292                 }
 293                 if (CustomXmlTrace.isCustomTraceTypeId(traceTypeId)) {
 294                     for (CustomXmlTraceDefinition def : CustomXmlTraceDefinition.loadAll()) {
 295                         String id = CustomXmlTrace.buildTraceTypeId(def.categoryName, def.definitionName);
 296                         if (traceTypeId.equals(id)) {
 297                             return new CustomXmlEvent(def);
 298                         }
 299                     }
 300                 }
 301                 IConfigurationElement ce = TRACE_TYPE_ATTRIBUTES.get(traceTypeId);
 302                 if (ce == null) {
 303                     return null;
 304                 }
 305                 ITmfEvent event = (ITmfEvent) ce.createExecutableExtension(TmfTraceType.EVENT_TYPE_ATTR);
 306                 return event;
 307             }
 308         } catch (CoreException e) {
 309             Activator.getDefault().logError("Error instantiating ITmfEvent object for trace " + getName(), e); //$NON-NLS-1$
 310         }
 311         return null;
 312     }
 313
 314     @Override
 315     public String getEditorId() {
 316         String traceTypeId = getTraceType();
 317         if (traceTypeId != null) {
 318             if (CustomTxtTrace.isCustomTraceTypeId(traceTypeId) || CustomXmlTrace.isCustomTraceTypeId(traceTypeId)) {
 319                 return TmfEventsEditor.ID;
 320             }
 321
 322             IConfigurationElement ce = TRACE_TYPE_UI_ATTRIBUTES.get(getTraceType());
 323             if (ce == null) {
 324                 /* This trace type does not define UI attributes */
 325                 return null;
 326             }
 327             IConfigurationElement[] defaultEditorCE = ce.getChildren(TmfTraceTypeUIUtils.DEFAULT_EDITOR_ELEM);
 328             if (defaultEditorCE.length == 1) {
 329                 return defaultEditorCE[0].getAttribute(TmfTraceType.ID_ATTR);
 330             }
 331         }
 332         return null;
 333     }
 334
 335     /**
 336      * Returns the file resource used to store bookmarks after creating it if
 337      * necessary. If the trace resource is a file, it is returned directly. If
 338      * the trace resource is a folder, a linked file is returned. The file will
 339      * be created if it does not exist.
 340      *
 341      * @return the bookmarks file
 342      * @throws CoreException
 343      *             if the bookmarks file cannot be created
 344      */
 345     @Override
 346     public IFile createBookmarksFile() throws CoreException {
 347         IFile file = getBookmarksFile();
 348         if (getResource() instanceof IFolder) {
 349             return createBookmarksFile(getProject().getTracesFolder().getResource(), ITmfEventsEditorConstants.TRACE_EDITOR_INPUT_TYPE);
 350         }
 351         return file;
 352     }
 353
 354     /**
 355      * Returns the file resource used to store bookmarks. The file may not
 356      * exist.
 357      *
 358      * @return the bookmarks file
 359      */
 360     @Override
 361     public IFile getBookmarksFile() {
 362         IFile file = null;
 363         IResource resource = getResource();
 364         if (resource instanceof IFile) {
 365             file = (IFile) resource;
 366         } else if (resource instanceof IFolder) {
 367             final IFolder folder = (IFolder) resource;
 368             file = folder.getFile(getName() + '_');
 369         }
 370         return file;
 371     }
 372
 373     /**
 374      * Returns the <code>TmfTraceElement</code> located under the
 375      * <code>TmfTracesFolder</code>.
 376      *
 377      * @return <code>this</code> if this element is under the
 378      *         <code>TmfTracesFolder</code> else the corresponding
 379      *         <code>TmfTraceElement</code> if this element is under
 380      *         <code>TmfExperimentElement</code>.
 381      */
 382     public TmfTraceElement getElementUnderTraceFolder() {
 383
 384         // If trace is under an experiment, return original trace from the
 385         // traces folder
 386         if (getParent() instanceof TmfExperimentElement) {
 387             for (TmfTraceElement aTrace : getProject().getTracesFolder().getTraces()) {
 388                 if (aTrace.getElementPath().equals(getElementPath())) {
 389                     return aTrace;
 390                 }
 391             }
 392         }
 393         return this;
 394     }
 395
 396     @Override
 397     public String getTypeName() {
 398         return Messages.TmfTraceElement_TypeName;
 399     }
 400
 401     // ------------------------------------------------------------------------
 402     // IActionFilter
 403     // ------------------------------------------------------------------------
 404
 405     @Override
 406     public boolean testAttribute(Object target, String name, String value) {
 407         if (name.equals(IS_LINKED)) {
 408             boolean isLinked = getResource().isLinked();
 409             return Boolean.toString(isLinked).equals(value);
 410         }
 411         return false;
 412     }
 413
 414     // ------------------------------------------------------------------------
 415     // IPropertySource2
 416     // ------------------------------------------------------------------------
 417
 418     @Override
 419     public Object getEditableValue() {
 420         return null;
 421     }
 422
 423     /**
 424      * Get the trace properties of this traceElement if the corresponding trace
 425      * is opened in an editor
 426      *
 427      * @return a map with the names and values of the trace properties
 428      *         respectively as keys and values
 429      */
 430     private Map<String, String> getTraceProperties() {
 431         for (ITmfTrace openedTrace : TmfTraceManager.getInstance().getOpenedTraces()) {
 432             for (ITmfTrace singleTrace : TmfTraceManager.getTraceSet(openedTrace)) {
 433                 if (getElementUnderTraceFolder().getResource().equals(singleTrace.getResource())) {
 434                     if (singleTrace instanceof ITmfPropertiesProvider) {
 435                         ITmfPropertiesProvider traceProperties = (ITmfPropertiesProvider) singleTrace;
 436                         return traceProperties.getProperties();
 437                     }
 438                 }
 439             }
 440         }
 441         return new HashMap<>();
 442     }
 443
 444     @Override
 445     public IPropertyDescriptor[] getPropertyDescriptors() {
 446         Map<String, String> traceProperties = getTraceProperties();
 447         if (!traceProperties.isEmpty()) {
 448             IPropertyDescriptor[] propertyDescriptorArray = new IPropertyDescriptor[traceProperties.size() + sfDescriptors.length];
 449             int index = 0;
 450             for (Map.Entry<String, String> varName : traceProperties.entrySet()) {
 451                 ReadOnlyTextPropertyDescriptor descriptor = new ReadOnlyTextPropertyDescriptor(this.getName() + "_" + varName.getKey(), varName.getKey()); //$NON-NLS-1$
 452                 descriptor.setCategory(TRACE_PROPERTIES_CATEGORY);
 453                 propertyDescriptorArray[index] = descriptor;
 454                 index++;
 455             }
 456             for (int i = 0; i < sfDescriptors.length; i++) {
 457                 propertyDescriptorArray[index] = sfDescriptors[i];
 458                 index++;
 459             }
 460             return propertyDescriptorArray;
 461         }
 462         return Arrays.copyOf(sfDescriptors, sfDescriptors.length);
 463     }
 464
 465     @Override
 466     public Object getPropertyValue(Object id) {
 467
 468         if (NAME.equals(id)) {
 469             return getName();
 470         }
 471
 472         if (PATH.equals(id)) {
 473             return getPath().toString();
 474         }
 475
 476         if (LOCATION.equals(id)) {
 477             return URIUtil.toUnencodedString(getLocation());
 478         }
 479
 480         if (IS_LINKED_PROPERTY.equals(id)) {
 481             return Boolean.valueOf(getResource().isLinked()).toString();
 482         }
 483
 484         if (SOURCE_LOCATION.equals(id)) {
 485             try {
 486                 String sourceLocation = getElementUnderTraceFolder().getResource().getPersistentProperty(TmfCommonConstants.SOURCE_LOCATION);
 487                 if (sourceLocation != null) {
 488                     return sourceLocation;
 489                 }
 490             } catch (CoreException e) {
 491             }
 492             return ""; //$NON-NLS-1$
 493         }
 494
 495         if (LAST_MODIFIED.equals(id)) {
 496             FileInfo fileInfo = getFileInfo();
 497             if (fileInfo == null) {
 498                 return ""; //$NON-NLS-1$
 499             }
 500             long date = fileInfo.lastModified;
 501             DateFormat format = DateFormat.getDateTimeInstance(DateFormat.LONG, DateFormat.MEDIUM);
 502             return format.format(new Date(date));
 503         }
 504
 505         if (SIZE.equals(id)) {
 506             FileInfo fileInfo = getFileInfo();
 507             if (fileInfo == null) {
 508                 return ""; //$NON-NLS-1$
 509             }
 510             if (getResource() instanceof IFolder) {
 511                 if (fileInfo.count <= FOLDER_MAX_COUNT) {
 512                     return NLS.bind(Messages.TmfTraceElement_FolderSizeString,
 513                             NumberFormat.getInstance().format(fileInfo.size), fileInfo.count);
 514                 }
 515                 return NLS.bind(Messages.TmfTraceElement_FolderSizeOverflowString,
 516                         NumberFormat.getInstance().format(fileInfo.size), FOLDER_MAX_COUNT);
 517             }
 518             return NLS.bind(Messages.TmfTraceElement_FileSizeString, NumberFormat.getInstance().format(fileInfo.size));
 519         }
 520
 521         if (TRACE_TYPE.equals(id)) {
 522             if (getTraceType() != null) {
 523                 TraceTypeHelper helper = TmfTraceType.getTraceType(getTraceType());
 524                 if (helper != null) {
 525                     return helper.getLabel();
 526                 }
 527             }
 528             return ""; //$NON-NLS-1$
 529         }
 530
 531         if (TIME_OFFSET.equals(id)) {
 532             long offset = TimestampTransformFactory.getTimestampTransform(getElementUnderTraceFolder().getResource()).transform(0);
 533             if (offset != 0) {
 534                 return OFFSET_FORMAT.format(offset);
 535             }
 536             return ""; //$NON-NLS-1$
 537         }
 538
 539         Map<String, String> traceProperties = getTraceProperties();
 540         if (id != null && !traceProperties.isEmpty()) {
 541             String key = (String) id;
 542             key = key.substring(this.getName().length() + 1); // remove name_
 543             String value = traceProperties.get(key);
 544             return value;
 545         }
 546
 547         return null;
 548     }
 549
 550     private FileInfo getFileInfo() {
 551         /* FileInfo is needed for both 'last modified' and 'size' properties.
 552          * It is freshly computed for one, and reused for the other, then
 553          * cleared so that the information can be refreshed the next time.
 554          */
 555         FileInfo fileInfo;
 556         if (fFileInfo == null) {
 557             try {
 558                 fileInfo = computeFileInfo(new FileInfo(), getResource());
 559             } catch (CoreException e) {
 560                 return null;
 561             }
 562             fFileInfo = fileInfo;
 563         } else {
 564             fileInfo = fFileInfo;
 565             fFileInfo = null;
 566         }
 567         return fileInfo;
 568     }
 569
 570     private FileInfo computeFileInfo(FileInfo fileInfo, IResource resource) throws CoreException {
 571         if (fileInfo == null || fileInfo.count > FOLDER_MAX_COUNT) {
 572             return fileInfo;
 573         }
 574         if (resource instanceof IFolder) {
 575             IFolder folder = (IFolder) resource;
 576             for (IResource member : folder.members()) {
 577                 computeFileInfo(fileInfo, member);
 578             }
 579             return fileInfo;
 580         }
 581         IFileInfo info = EFS.getStore(resource.getLocationURI()).fetchInfo();
 582         fileInfo.lastModified = Math.max(fileInfo.lastModified, info.getLastModified());
 583         fileInfo.size += info.getLength();
 584         fileInfo.count++;
 585         return fileInfo;
 586     }
 587
 588     @Override
 589     public void resetPropertyValue(Object id) {
 590     }
 591
 592     @Override
 593     public void setPropertyValue(Object id, Object value) {
 594     }
 595
 596     @Override
 597     public boolean isPropertyResettable(Object id) {
 598         return false;
 599     }
 600
 601     @Override
 602     public boolean isPropertySet(Object id) {
 603         return false;
 604     }
 605
 606     /**
 607      * Copy this trace in the trace folder. No other parameters are mentioned so
 608      * the trace is copied in this element's project trace folder
 609      *
 610      * @param newName
 611      *            The new trace name
 612      * @return the new Resource object
 613      */
 614     public TmfTraceElement copy(String newName) {
 615         TmfTraceFolder folder = (TmfTraceFolder) getParent();
 616         IResource res = super.copy(newName, false);
 617         for (TmfTraceElement trace : folder.getTraces()) {
 618             if (trace.getResource().equals(res)) {
 619                 return trace;
 620             }
 621         }
 622         return null;
 623     }
 624
 625     /**
 626      * Close opened editors associated with this trace.
 627      */
 628     @Override
 629     public void closeEditors() {
 630         super.closeEditors();
 631
 632         // Close experiments that contain the trace if open
 633         if (getParent() instanceof TmfTraceFolder) {
 634             TmfExperimentFolder experimentsFolder = getProject().getExperimentsFolder();
 635             for (TmfExperimentElement experiment : experimentsFolder.getExperiments()) {
 636                 for (TmfTraceElement trace : experiment.getTraces()) {
 637                     if (trace.getElementPath().equals(getElementPath())) {
 638                         experiment.closeEditors();
 639                         break;
 640                     }
 641                 }
 642             }
 643         } else if (getParent() instanceof TmfExperimentElement) {
 644             TmfExperimentElement experiment = (TmfExperimentElement) getParent();
 645             experiment.closeEditors();
 646         }
 647     }
 648
 649     /**
 650      * Delete the trace resource, remove it from experiments and delete its
 651      * supplementary files
 652      *
 653      * @param progressMonitor
 654      *            a progress monitor, or null if progress reporting is not
 655      *            desired
 656      *
 657      * @throws CoreException
 658      *             thrown when IResource.delete fails
 659      */
 660     public void delete(IProgressMonitor progressMonitor) throws CoreException {
 661         // Close editors in UI Thread
 662         Display.getDefault().syncExec(new Runnable() {
 663             @Override
 664             public void run() {
 665                 closeEditors();
 666             }
 667         });
 668
 669         IPath path = getResource().getLocation();
 670         if (path != null) {
 671             if (getParent() instanceof TmfTraceFolder) {
 672                 TmfExperimentFolder experimentFolder = getProject().getExperimentsFolder();
 673
 674                 // Propagate the removal to traces
 675                 for (TmfExperimentElement experiment : experimentFolder.getExperiments()) {
 676                     List<TmfTraceElement> toRemove = new LinkedList<>();
 677                     for (TmfTraceElement trace : experiment.getTraces()) {
 678                         if (trace.getElementPath().equals(getElementPath())) {
 679                             toRemove.add(trace);
 680                         }
 681                     }
 682                     for (TmfTraceElement child : toRemove) {
 683                         experiment.removeTrace(child);
 684                     }
 685                 }
 686
 687                 // Delete supplementary files
 688                 deleteSupplementaryFolder();
 689
 690             } else if (getParent() instanceof TmfExperimentElement) {
 691                 TmfExperimentElement experimentElement = (TmfExperimentElement) getParent();
 692                 experimentElement.removeTrace(this);
 693             }
 694         }
 695
 696         // Finally, delete the trace
 697         getResource().delete(true, progressMonitor);
 698     }
 699
 700 }