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

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