org.eclipse.linuxtools.tmf.ui/src/org/eclipse/linuxtools/tmf/ui/editors/TmfEventsEditor.java

   1 /*******************************************************************************
   2  * Copyright (c) 2010, 2013 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.editors;
  14
  15 import java.lang.reflect.Constructor;
  16 import java.lang.reflect.InvocationTargetException;
  17 import java.util.List;
  18
  19 import org.eclipse.core.resources.IFile;
  20 import org.eclipse.core.resources.IMarker;
  21 import org.eclipse.core.resources.IMarkerDelta;
  22 import org.eclipse.core.resources.IResource;
  23 import org.eclipse.core.resources.IResourceChangeEvent;
  24 import org.eclipse.core.resources.IResourceChangeListener;
  25 import org.eclipse.core.resources.IResourceDelta;
  26 import org.eclipse.core.resources.ResourcesPlugin;
  27 import org.eclipse.core.runtime.CoreException;
  28 import org.eclipse.core.runtime.IConfigurationElement;
  29 import org.eclipse.core.runtime.IProgressMonitor;
  30 import org.eclipse.core.runtime.InvalidRegistryObjectException;
  31 import org.eclipse.core.runtime.ListenerList;
  32 import org.eclipse.core.runtime.Platform;
  33 import org.eclipse.jface.action.IStatusLineManager;
  34 import org.eclipse.jface.util.SafeRunnable;
  35 import org.eclipse.jface.viewers.ISelection;
  36 import org.eclipse.jface.viewers.ISelectionChangedListener;
  37 import org.eclipse.jface.viewers.ISelectionProvider;
  38 import org.eclipse.jface.viewers.SelectionChangedEvent;
  39 import org.eclipse.jface.viewers.StructuredSelection;
  40 import org.eclipse.linuxtools.internal.tmf.ui.Activator;
  41 import org.eclipse.linuxtools.internal.tmf.ui.parsers.custom.CustomEventsTable;
  42 import org.eclipse.linuxtools.internal.tmf.ui.parsers.custom.CustomTxtTrace;
  43 import org.eclipse.linuxtools.internal.tmf.ui.parsers.custom.CustomXmlTrace;
  44 import org.eclipse.linuxtools.tmf.core.TmfCommonConstants;
  45 import org.eclipse.linuxtools.tmf.core.event.ITmfEvent;
  46 import org.eclipse.linuxtools.tmf.core.exceptions.TmfTraceException;
  47 import org.eclipse.linuxtools.tmf.core.signal.TmfSignalHandler;
  48 import org.eclipse.linuxtools.tmf.core.signal.TmfTimestampFormatUpdateSignal;
  49 import org.eclipse.linuxtools.tmf.core.signal.TmfTraceClosedSignal;
  50 import org.eclipse.linuxtools.tmf.core.signal.TmfTraceOpenedSignal;
  51 import org.eclipse.linuxtools.tmf.core.signal.TmfTraceSelectedSignal;
  52 import org.eclipse.linuxtools.tmf.core.trace.ITmfContext;
  53 import org.eclipse.linuxtools.tmf.core.trace.ITmfTrace;
  54 import org.eclipse.linuxtools.tmf.core.trace.TmfExperiment;
  55 import org.eclipse.linuxtools.tmf.core.trace.TmfTrace;
  56 import org.eclipse.linuxtools.tmf.ui.project.model.ITmfProjectModelElement;
  57 import org.eclipse.linuxtools.tmf.ui.project.model.Messages;
  58 import org.eclipse.linuxtools.tmf.ui.project.model.TmfExperimentElement;
  59 import org.eclipse.linuxtools.tmf.ui.project.model.TmfNavigatorContentProvider;
  60 import org.eclipse.linuxtools.tmf.ui.project.model.TmfProjectElement;
  61 import org.eclipse.linuxtools.tmf.ui.project.model.TmfProjectRegistry;
  62 import org.eclipse.linuxtools.tmf.ui.project.model.TmfTraceElement;
  63 import org.eclipse.linuxtools.tmf.ui.project.model.TmfTraceType;
  64 import org.eclipse.linuxtools.tmf.ui.viewers.events.TmfEventsTable;
  65 import org.eclipse.swt.widgets.Composite;
  66 import org.eclipse.swt.widgets.Display;
  67 import org.eclipse.ui.IEditorInput;
  68 import org.eclipse.ui.IEditorPart;
  69 import org.eclipse.ui.IEditorSite;
  70 import org.eclipse.ui.IFileEditorInput;
  71 import org.eclipse.ui.IPartListener;
  72 import org.eclipse.ui.IPropertyListener;
  73 import org.eclipse.ui.IReusableEditor;
  74 import org.eclipse.ui.IWorkbenchPart;
  75 import org.eclipse.ui.PartInitException;
  76 import org.eclipse.ui.ide.IGotoMarker;
  77 import org.eclipse.ui.part.FileEditorInput;
  78 import org.eclipse.ui.views.properties.IPropertySheetPage;
  79 import org.osgi.framework.Bundle;
  80
  81 /**
  82  * Editor for TMF events
  83  *
  84  * @version 1.0
  85  * @author Patrick Tasse
  86  * @since 2.0
  87  */
  88 public class TmfEventsEditor extends TmfEditor implements ITmfTraceEditor, IReusableEditor, IPropertyListener, IResourceChangeListener, ISelectionProvider, ISelectionChangedListener, IPartListener {
  89
  90     /** ID for this class */
  91     public static final String ID = "org.eclipse.linuxtools.tmf.ui.editors.events"; //$NON-NLS-1$
  92
  93     private TmfEventsTable fEventsTable;
  94     private IFile fFile;
  95     private ITmfTrace fTrace;
  96     private Composite fParent;
  97     private ListenerList fSelectionChangedListeners = new ListenerList();
  98     private boolean fTraceSelected;
  99
 100     @Override
 101     public void doSave(final IProgressMonitor monitor) {
 102     }
 103
 104     @Override
 105     public void doSaveAs() {
 106     }
 107
 108     @Override
 109     public void init(final IEditorSite site, IEditorInput input) throws PartInitException {
 110         IFileEditorInput fileEditorInput;
 111         if (input instanceof TmfEditorInput) {
 112             fFile = ((TmfEditorInput) input).getFile();
 113             fTrace = ((TmfEditorInput) input).getTrace();
 114             /* change the input to a FileEditorInput to allow open handlers to find this editor */
 115             fileEditorInput = new FileEditorInput(fFile);
 116         } else if (input instanceof IFileEditorInput) {
 117             fileEditorInput = (IFileEditorInput) input;
 118             fFile = fileEditorInput.getFile();
 119             if (fFile == null) {
 120                 throw new PartInitException("Invalid IFileEditorInput: " + fileEditorInput); //$NON-NLS-1$
 121             }
 122             try {
 123                 final String traceTypeId = fFile.getPersistentProperty(TmfCommonConstants.TRACETYPE);
 124                 if (traceTypeId == null) {
 125                     throw new PartInitException(Messages.TmfOpenTraceHelper_NoTraceType);
 126                 }
 127                 if (traceTypeId.equals(TmfExperiment.class.getCanonicalName())) {
 128                     // Special case: experiment bookmark resource
 129                     final TmfNavigatorContentProvider ncp = new TmfNavigatorContentProvider();
 130                     ncp.getChildren(fFile.getProject()); // force the model to be populated
 131                     final TmfProjectElement project = TmfProjectRegistry.getProject(fFile.getProject());
 132                     if (project == null) {
 133                         throw new PartInitException(Messages.TmfOpenTraceHelper_NoTraceType);
 134                     }
 135                     for (final ITmfProjectModelElement projectElement : project.getExperimentsFolder().getChildren()) {
 136                         final String traceName = fFile.getParent().getName();
 137                         if (projectElement.getName().equals(traceName)) {
 138                             final TmfExperimentElement experimentElement = (TmfExperimentElement) projectElement;
 139                             // Instantiate the experiment's traces
 140                             final List<TmfTraceElement> traceEntries = experimentElement.getTraces();
 141                             final int nbTraces = traceEntries.size();
 142                             int cacheSize = Integer.MAX_VALUE;
 143                             final ITmfTrace[] traces = new ITmfTrace[nbTraces];
 144                             for (int i = 0; i < nbTraces; i++) {
 145                                 final TmfTraceElement traceElement = traceEntries.get(i).getElementUnderTraceFolder();
 146                                 final ITmfTrace trace = traceElement.instantiateTrace();
 147                                 final ITmfEvent traceEvent = traceElement.instantiateEvent();
 148                                 if ((trace == null) || (traceEvent == null)) {
 149                                     for (int j = 0; j < i; j++) {
 150                                         traces[j].dispose();
 151                                     }
 152                                     throw new PartInitException(Messages.TmfOpenTraceHelper_NoTraceType);
 153                                 }
 154                                 try {
 155                                     trace.initTrace(traceElement.getResource(), traceElement.getLocation().getPath(), traceEvent.getClass());
 156                                 } catch (final TmfTraceException e) {
 157                                     throw new PartInitException(Messages.TmfOpenTraceHelper_InitError, e);
 158                                 }
 159                                 cacheSize = Math.min(cacheSize, trace.getCacheSize());
 160                                 traces[i] = trace;
 161                             }
 162                             final TmfExperiment experiment = new TmfExperiment(ITmfEvent.class, experimentElement.getName(), traces, cacheSize, experimentElement.getResource());
 163                             experiment.setBookmarksFile(fFile);
 164                             fTrace = experiment;
 165                             break;
 166                         }
 167                     }
 168                 } else if (traceTypeId.equals(TmfTrace.class.getCanonicalName())) {
 169                     // Special case: trace bookmark resource
 170                     final TmfNavigatorContentProvider ncp = new TmfNavigatorContentProvider();
 171                     ncp.getChildren(fFile.getProject()); // force the model to be populated
 172                     final TmfProjectElement project = TmfProjectRegistry.getProject(fFile.getProject());
 173                     for (final ITmfProjectModelElement projectElement : project.getTracesFolder().getChildren()) {
 174                         final String traceName = fFile.getParent().getName();
 175                         if (projectElement.getName().equals(traceName)) {
 176                             final TmfTraceElement traceElement = (TmfTraceElement) projectElement;
 177                             // Instantiate the trace
 178                             final ITmfTrace trace = traceElement.instantiateTrace();
 179                             final ITmfEvent traceEvent = traceElement.instantiateEvent();
 180                             if ((trace == null) || (traceEvent == null)) {
 181                                 throw new PartInitException(Messages.TmfOpenTraceHelper_NoTraceType);
 182                             }
 183                             try {
 184                                 trace.initTrace(traceElement.getResource(), traceElement.getLocation().getPath(), traceEvent.getClass());
 185                             } catch (final TmfTraceException e) {
 186                                 throw new PartInitException(Messages.TmfOpenTraceHelper_InitError, e);
 187                             }
 188                             fTrace = trace;
 189                             break;
 190                         }
 191                     }
 192                 } else {
 193                     final TmfNavigatorContentProvider ncp = new TmfNavigatorContentProvider();
 194                     ncp.getChildren(fFile.getProject()); // force the model to be populated
 195                     final TmfProjectElement project = TmfProjectRegistry.getProject(fFile.getProject());
 196                     for (final ITmfProjectModelElement projectElement : project.getTracesFolder().getChildren()) {
 197                         if (projectElement.getResource().equals(fFile)) {
 198                             final TmfTraceElement traceElement = (TmfTraceElement) projectElement;
 199                             // Instantiate the trace
 200                             final ITmfTrace trace = traceElement.instantiateTrace();
 201                             final ITmfEvent traceEvent = traceElement.instantiateEvent();
 202                             if ((trace == null) || (traceEvent == null)) {
 203                                 throw new PartInitException(Messages.TmfOpenTraceHelper_NoTraceType);
 204                             }
 205                             try {
 206                                 trace.initTrace(traceElement.getResource(), traceElement.getLocation().getPath(), traceEvent.getClass());
 207                             } catch (final TmfTraceException e) {
 208                                 throw new PartInitException(Messages.TmfOpenTraceHelper_InitError, e);
 209                             }
 210                             fTrace = trace;
 211                             break;
 212                         }
 213                     }
 214                 }
 215             } catch (final PartInitException e) {
 216                 throw e;
 217             } catch (final InvalidRegistryObjectException e) {
 218                 Activator.getDefault().logError("Error initializing TmfEventsEditor", e); //$NON-NLS-1$
 219             } catch (final CoreException e) {
 220                 Activator.getDefault().logError("Error initializing TmfEventsEditor", e); //$NON-NLS-1$
 221             }
 222         } else {
 223             throw new PartInitException("Invalid IEditorInput: " + input.getClass()); //$NON-NLS-1$
 224         }
 225         if (fTrace == null) {
 226             throw new PartInitException("Invalid IEditorInput: " + fFile.getName()); //$NON-NLS-1$
 227         }
 228         super.setSite(site);
 229         super.setInput(fileEditorInput);
 230     }
 231
 232     @Override
 233     public boolean isDirty() {
 234         return false;
 235     }
 236
 237     @Override
 238     public boolean isSaveAsAllowed() {
 239         return false;
 240     }
 241
 242     @Override
 243     public void setInput(final IEditorInput input) {
 244         super.setInput(input);
 245         firePropertyChange(IEditorPart.PROP_INPUT);
 246     }
 247
 248     @Override
 249     public void propertyChanged(final Object source, final int propId) {
 250         if (propId == IEditorPart.PROP_INPUT && getEditorInput() instanceof TmfEditorInput) {
 251             broadcast(new TmfTraceClosedSignal(this, fTrace));
 252             fTraceSelected = false;
 253             fFile = ((TmfEditorInput) getEditorInput()).getFile();
 254             fTrace = ((TmfEditorInput) getEditorInput()).getTrace();
 255             /* change the input to a FileEditorInput to allow open handlers to find this editor */
 256             super.setInput(new FileEditorInput(fFile));
 257             fEventsTable.dispose();
 258             if (fTrace != null) {
 259                 fEventsTable = createEventsTable(fParent, fTrace.getCacheSize());
 260                 fEventsTable.addSelectionChangedListener(this);
 261                 fEventsTable.setTrace(fTrace, true);
 262                 fEventsTable.refreshBookmarks(fFile);
 263
 264                 /* ensure start time is set */
 265                 final ITmfContext context = fTrace.seekEvent(0);
 266                 fTrace.getNext(context);
 267                 context.dispose();
 268
 269                 broadcast(new TmfTraceOpenedSignal(this, fTrace, fFile));
 270             } else {
 271                 fEventsTable = new TmfEventsTable(fParent, 0);
 272                 fEventsTable.addSelectionChangedListener(this);
 273             }
 274             fParent.layout();
 275         }
 276     }
 277
 278     @Override
 279     public void createPartControl(final Composite parent) {
 280         fParent = parent;
 281         if (fTrace != null) {
 282             setPartName(fTrace.getName());
 283             fEventsTable = createEventsTable(parent, fTrace.getCacheSize());
 284             fEventsTable.addSelectionChangedListener(this);
 285             fEventsTable.setTrace(fTrace, true);
 286             fEventsTable.refreshBookmarks(fFile);
 287
 288             /* ensure start time is set */
 289             final ITmfContext context = fTrace.seekEvent(0);
 290             fTrace.getNext(context);
 291             context.dispose();
 292
 293             broadcast(new TmfTraceOpenedSignal(this, fTrace, fFile));
 294         } else {
 295             setPartName(getEditorInput().getName());
 296             fEventsTable = new TmfEventsTable(parent, 0);
 297             fEventsTable.addSelectionChangedListener(this);
 298         }
 299         IStatusLineManager statusLineManager = getEditorSite().getActionBars().getStatusLineManager();
 300         fEventsTable.setStatusLineManager(statusLineManager);
 301         addPropertyListener(this);
 302         ResourcesPlugin.getWorkspace().addResourceChangeListener(this, IResourceChangeEvent.POST_CHANGE);
 303         // we need to wrap the ISelectionProvider interface in the editor because
 304         // the events table can be replaced later while the selection changed listener
 305         // is only added once by the platform to the selection provider set here
 306         getSite().setSelectionProvider(this);
 307         getSite().getPage().addPartListener(this);
 308     }
 309
 310     @Override
 311     public void dispose() {
 312         if (getSite() != null) {
 313             getSite().getPage().removePartListener(this);
 314         }
 315         ResourcesPlugin.getWorkspace().removeResourceChangeListener(this);
 316         removePropertyListener(this);
 317         if (fTrace != null) {
 318             broadcast(new TmfTraceClosedSignal(this, fTrace));
 319         }
 320         if (fEventsTable != null) {
 321             fEventsTable.dispose();
 322         }
 323         super.dispose();
 324     }
 325
 326     /**
 327      * Create the events table
 328      *
 329      * @param parent the parent composite
 330      * @param cacheSize the cache size
 331      * @return an events table instance
 332      */
 333     protected TmfEventsTable createEventsTable(final Composite parent, final int cacheSize) {
 334         TmfEventsTable eventsTable = getEventsTable(parent, cacheSize);
 335         if (eventsTable == null) {
 336             eventsTable = new TmfEventsTable(parent, cacheSize);
 337         }
 338         return eventsTable;
 339     }
 340
 341     private TmfEventsTable getEventsTable(final Composite parent, final int cacheSize) {
 342         if (fTrace instanceof TmfExperiment) {
 343             return getExperimentEventsTable((TmfExperiment) fTrace, parent, cacheSize);
 344         }
 345         TmfEventsTable eventsTable = null;
 346         try {
 347             if (fTrace.getResource() == null) {
 348                 return null;
 349             }
 350             final String traceType = fTrace.getResource().getPersistentProperty(TmfCommonConstants.TRACETYPE);
 351             if (traceType == null) {
 352                 return null;
 353             }
 354             if (traceType.startsWith(CustomTxtTrace.class.getCanonicalName())) {
 355                 return new CustomEventsTable(((CustomTxtTrace) fTrace).getDefinition(), parent, cacheSize);
 356             }
 357             if (traceType.startsWith(CustomXmlTrace.class.getCanonicalName())) {
 358                 return new CustomEventsTable(((CustomXmlTrace) fTrace).getDefinition(), parent, cacheSize);
 359             }
 360             for (final IConfigurationElement ce : TmfTraceType.getTypeElements()) {
 361                 if (ce.getAttribute(TmfTraceType.ID_ATTR).equals(traceType)) {
 362                     final IConfigurationElement[] eventsTableTypeCE = ce.getChildren(TmfTraceType.EVENTS_TABLE_TYPE_ELEM);
 363                     if (eventsTableTypeCE.length != 1) {
 364                         break;
 365                     }
 366                     final String eventsTableType = eventsTableTypeCE[0].getAttribute(TmfTraceType.CLASS_ATTR);
 367                     if ((eventsTableType == null) || (eventsTableType.length() == 0)) {
 368                         break;
 369                     }
 370                     final Bundle bundle = Platform.getBundle(ce.getContributor().getName());
 371                     final Class<?> c = bundle.loadClass(eventsTableType);
 372                     final Class<?>[] constructorArgs = new Class[] { Composite.class, int.class };
 373                     final Constructor<?> constructor = c.getConstructor(constructorArgs);
 374                     final Object[] args = new Object[] { parent, cacheSize };
 375                     eventsTable = (TmfEventsTable) constructor.newInstance(args);
 376                     break;
 377                 }
 378             }
 379         } catch (final InvalidRegistryObjectException e) {
 380             Activator.getDefault().logError("Error getting TmfEventsTable", e); //$NON-NLS-1$
 381         } catch (final CoreException e) {
 382             Activator.getDefault().logError("Error getting TmfEventsTable", e); //$NON-NLS-1$
 383         } catch (final ClassNotFoundException e) {
 384             Activator.getDefault().logError("Error getting TmfEventsTable", e); //$NON-NLS-1$
 385         } catch (final SecurityException e) {
 386             Activator.getDefault().logError("Error getting TmfEventsTable", e); //$NON-NLS-1$
 387         } catch (final NoSuchMethodException e) {
 388             Activator.getDefault().logError("Error getting TmfEventsTable", e); //$NON-NLS-1$
 389         } catch (final IllegalArgumentException e) {
 390             Activator.getDefault().logError("Error getting TmfEventsTable", e); //$NON-NLS-1$
 391         } catch (final InstantiationException e) {
 392             Activator.getDefault().logError("Error getting TmfEventsTable", e); //$NON-NLS-1$
 393         } catch (final IllegalAccessException e) {
 394             Activator.getDefault().logError("Error getting TmfEventsTable", e); //$NON-NLS-1$
 395         } catch (final InvocationTargetException e) {
 396             Activator.getDefault().logError("Error getting TmfEventsTable", e); //$NON-NLS-1$
 397         }
 398         return eventsTable;
 399     }
 400
 401     /**
 402      * Get the events table for an experiment. If all traces in the experiment
 403      * are of the same type, use the extension point specified event table
 404      *
 405      * @param experiment
 406      *            the experiment
 407      * @param parent
 408      *            the parent Composite
 409      * @param cacheSize
 410      *            the event table cache size
 411      * @return an events table of the appropriate type
 412      */
 413     private static TmfEventsTable getExperimentEventsTable(
 414             final TmfExperiment experiment, final Composite parent,
 415             final int cacheSize) {
 416         TmfEventsTable eventsTable = null;
 417         String commonTraceType = null;
 418         try {
 419             for (final ITmfTrace trace : experiment.getTraces()) {
 420                 final IResource resource = trace.getResource();
 421                 if (resource == null) {
 422                     return null;
 423                 }
 424                 final String traceType = resource.getPersistentProperty(TmfCommonConstants.TRACETYPE);
 425                 if ((commonTraceType != null) && !commonTraceType.equals(traceType)) {
 426                     return null;
 427                 }
 428                 commonTraceType = traceType;
 429             }
 430             if (commonTraceType == null) {
 431                 return null;
 432             }
 433             if (commonTraceType.startsWith(CustomTxtTrace.class.getCanonicalName())) {
 434                 return new CustomEventsTable(((CustomTxtTrace) experiment.getTraces()[0]).getDefinition(), parent, cacheSize);
 435             }
 436             if (commonTraceType.startsWith(CustomXmlTrace.class.getCanonicalName())) {
 437                 return new CustomEventsTable(((CustomXmlTrace) experiment.getTraces()[0]).getDefinition(), parent, cacheSize);
 438             }
 439             for (final IConfigurationElement ce : TmfTraceType.getTypeElements()) {
 440                 if (ce.getAttribute(TmfTraceType.ID_ATTR).equals(commonTraceType)) {
 441                     final IConfigurationElement[] eventsTableTypeCE = ce.getChildren(TmfTraceType.EVENTS_TABLE_TYPE_ELEM);
 442                     if (eventsTableTypeCE.length != 1) {
 443                         break;
 444                     }
 445                     final String eventsTableType = eventsTableTypeCE[0].getAttribute(TmfTraceType.CLASS_ATTR);
 446                     if ((eventsTableType == null) || (eventsTableType.length() == 0)) {
 447                         break;
 448                     }
 449                     final Bundle bundle = Platform.getBundle(ce.getContributor().getName());
 450                     final Class<?> c = bundle.loadClass(eventsTableType);
 451                     final Class<?>[] constructorArgs = new Class[] { Composite.class, int.class };
 452                     final Constructor<?> constructor = c.getConstructor(constructorArgs);
 453                     final Object[] args = new Object[] { parent, cacheSize };
 454                     eventsTable = (TmfEventsTable) constructor.newInstance(args);
 455                     break;
 456                 }
 457             }
 458         } catch (final CoreException e) {
 459             Activator.getDefault().logError("Error getting TmfEventsTable for experiment", e); //$NON-NLS-1$
 460         } catch (final InvalidRegistryObjectException e) {
 461             Activator.getDefault().logError("Error getting TmfEventsTable for experiment", e); //$NON-NLS-1$
 462         } catch (final SecurityException e) {
 463             Activator.getDefault().logError("Error getting TmfEventsTable for experiment", e); //$NON-NLS-1$
 464         } catch (final IllegalArgumentException e) {
 465             Activator.getDefault().logError("Error getting TmfEventsTable for experiment", e); //$NON-NLS-1$
 466         } catch (final ClassNotFoundException e) {
 467             Activator.getDefault().logError("Error getting TmfEventsTable for experiment", e); //$NON-NLS-1$
 468         } catch (final NoSuchMethodException e) {
 469             Activator.getDefault().logError("Error getting TmfEventsTable for experiment", e); //$NON-NLS-1$
 470         } catch (final InstantiationException e) {
 471             Activator.getDefault().logError("Error getting TmfEventsTable for experiment", e); //$NON-NLS-1$
 472         } catch (final IllegalAccessException e) {
 473             Activator.getDefault().logError("Error getting TmfEventsTable for experiment", e); //$NON-NLS-1$
 474         } catch (final InvocationTargetException e) {
 475             Activator.getDefault().logError("Error getting TmfEventsTable for experiment", e); //$NON-NLS-1$
 476         }
 477         return eventsTable;
 478     }
 479
 480     @Override
 481     public ITmfTrace getTrace() {
 482         return fTrace;
 483     }
 484
 485     @Override
 486     public IFile getBookmarksFile() {
 487         return fFile;
 488     }
 489
 490     @Override
 491     public void setFocus() {
 492         fEventsTable.setFocus();
 493     }
 494
 495     @Override
 496     public Object getAdapter(final Class adapter) {
 497         if (IGotoMarker.class.equals(adapter)) {
 498             return fEventsTable;
 499         } else if (IPropertySheetPage.class.equals(adapter)) {
 500             return new UnsortedPropertySheetPage();
 501         }
 502         return super.getAdapter(adapter);
 503     }
 504
 505     @Override
 506     public void resourceChanged(final IResourceChangeEvent event) {
 507         for (final IMarkerDelta delta : event.findMarkerDeltas(IMarker.BOOKMARK, false)) {
 508             if (delta.getResource().equals(fFile)) {
 509                 if (delta.getKind() == IResourceDelta.REMOVED) {
 510                     final IMarker bookmark = delta.getMarker();
 511                     Display.getDefault().asyncExec(new Runnable() {
 512                         @Override
 513                         public void run() {
 514                             fEventsTable.removeBookmark(bookmark);
 515                         }
 516                     });
 517                 } else if (delta.getKind() == IResourceDelta.CHANGED) {
 518                     Display.getDefault().asyncExec(new Runnable() {
 519                         @Override
 520                         public void run() {
 521                             fEventsTable.getTable().refresh();
 522                         }
 523                     });
 524                 }
 525             }
 526         }
 527     }
 528
 529     // ------------------------------------------------------------------------
 530     // ISelectionProvider
 531     // ------------------------------------------------------------------------
 532
 533     /**
 534      * @since 2.0
 535      */
 536     @Override
 537     public void addSelectionChangedListener(ISelectionChangedListener listener) {
 538         fSelectionChangedListeners.add(listener);
 539     }
 540
 541     /**
 542      * @since 2.0
 543      */
 544     @Override
 545     public ISelection getSelection() {
 546         if (fEventsTable == null) {
 547             return StructuredSelection.EMPTY;
 548         }
 549         return fEventsTable.getSelection();
 550     }
 551
 552     /**
 553      * @since 2.0
 554      */
 555     @Override
 556     public void removeSelectionChangedListener(ISelectionChangedListener listener) {
 557         fSelectionChangedListeners.remove(listener);
 558     }
 559
 560     /**
 561      * @since 2.0
 562      */
 563     @Override
 564     public void setSelection(ISelection selection) {
 565         // not implemented
 566     }
 567
 568     /**
 569      * Notifies any selection changed listeners that the viewer's selection has changed.
 570      * Only listeners registered at the time this method is called are notified.
 571      *
 572      * @param event a selection changed event
 573      *
 574      * @see ISelectionChangedListener#selectionChanged
 575      * @since 2.0
 576      */
 577     protected void fireSelectionChanged(final SelectionChangedEvent event) {
 578         Object[] listeners = fSelectionChangedListeners.getListeners();
 579         for (int i = 0; i < listeners.length; ++i) {
 580             final ISelectionChangedListener l = (ISelectionChangedListener) listeners[i];
 581             SafeRunnable.run(new SafeRunnable() {
 582                 @Override
 583                 public void run() {
 584                     l.selectionChanged(event);
 585                 }
 586             });
 587         }
 588     }
 589
 590     // ------------------------------------------------------------------------
 591     // ISelectionChangedListener
 592     // ------------------------------------------------------------------------
 593
 594     /**
 595      * @since 2.0
 596      */
 597     @Override
 598     public void selectionChanged(SelectionChangedEvent event) {
 599         fireSelectionChanged(event);
 600     }
 601
 602     // ------------------------------------------------------------------------
 603     // IPartListener
 604     // ------------------------------------------------------------------------
 605
 606     /**
 607      * @since 2.0
 608      */
 609     @Override
 610     public void partActivated(IWorkbenchPart part) {
 611         if (part == this && fTrace != null) {
 612             if (fTraceSelected) {
 613                 return;
 614             }
 615             fTraceSelected = true;
 616             broadcast(new TmfTraceSelectedSignal(this, fTrace));
 617         }
 618     }
 619
 620     /**
 621      * @since 2.0
 622      */
 623     @Override
 624     public void partBroughtToTop(IWorkbenchPart part) {
 625         if (part == this && fTrace != null) {
 626             if (fTraceSelected) {
 627                 return;
 628             }
 629             fTraceSelected = true;
 630             broadcast(new TmfTraceSelectedSignal(this, fTrace));
 631         }
 632     }
 633
 634     /**
 635      * @since 2.0
 636      */
 637     @Override
 638     public void partClosed(IWorkbenchPart part) {
 639     }
 640
 641     /**
 642      * @since 2.0
 643      */
 644     @Override
 645     public void partDeactivated(IWorkbenchPart part) {
 646     }
 647
 648     /**
 649      * @since 2.0
 650      */
 651     @Override
 652     public void partOpened(IWorkbenchPart part) {
 653     }
 654
 655     // ------------------------------------------------------------------------
 656     // Global commands
 657     // ------------------------------------------------------------------------
 658
 659     /**
 660      * Add a bookmark
 661      */
 662     public void addBookmark() {
 663         fEventsTable.addBookmark(fFile);
 664     }
 665
 666
 667     // ------------------------------------------------------------------------
 668     // Signal handlers
 669     // ------------------------------------------------------------------------
 670
 671     /**
 672      * Handler for the Trace Selected signal
 673      *
 674      * @param signal The incoming signal
 675      */
 676     @TmfSignalHandler
 677     public void traceSelected(final TmfTraceSelectedSignal signal) {
 678         if ((signal.getSource() != this)) {
 679             if (signal.getTrace().equals(fTrace)) {
 680                 getSite().getPage().bringToTop(this);
 681             } else {
 682                 fTraceSelected = false;
 683             }
 684         }
 685     }
 686
 687     /**
 688      * Update the display to use the updated timestamp format
 689      *
 690      * @param signal the incoming signal
 691      * @since 2.0
 692      */
 693     @TmfSignalHandler
 694     public void timestampFormatUpdated(TmfTimestampFormatUpdateSignal signal) {
 695         if (fEventsTable != null) {
 696             fEventsTable.refresh();
 697         }
 698     }
 699
 700 }