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

   1 /*******************************************************************************
   2  * Copyright (c) 2010, 2016 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  *   Patrick Tasse - Initial API and implementation
  11  *   Geneviève Bastien - Experiment instantiated with experiment type
  12  *******************************************************************************/
  13
  14 package org.eclipse.tracecompass.tmf.ui.editors;
  15
  16 import java.util.HashSet;
  17 import java.util.List;
  18 import java.util.Set;
  19
  20 import org.eclipse.core.resources.IFile;
  21 import org.eclipse.core.resources.IMarker;
  22 import org.eclipse.core.resources.IMarkerDelta;
  23 import org.eclipse.core.resources.IResource;
  24 import org.eclipse.core.resources.IResourceChangeEvent;
  25 import org.eclipse.core.resources.IResourceChangeListener;
  26 import org.eclipse.core.resources.IResourceDelta;
  27 import org.eclipse.core.resources.ResourcesPlugin;
  28 import org.eclipse.core.runtime.CoreException;
  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.jdt.annotation.NonNull;
  33 import org.eclipse.jdt.annotation.Nullable;
  34 import org.eclipse.jface.action.IStatusLineManager;
  35 import org.eclipse.jface.util.SafeRunnable;
  36 import org.eclipse.jface.viewers.ISelection;
  37 import org.eclipse.jface.viewers.ISelectionChangedListener;
  38 import org.eclipse.jface.viewers.ISelectionProvider;
  39 import org.eclipse.jface.viewers.SelectionChangedEvent;
  40 import org.eclipse.jface.viewers.StructuredSelection;
  41 import org.eclipse.swt.widgets.Composite;
  42 import org.eclipse.swt.widgets.Display;
  43 import org.eclipse.tracecompass.internal.tmf.ui.Activator;
  44 import org.eclipse.tracecompass.internal.tmf.ui.editors.ITmfEventsEditorConstants;
  45 import org.eclipse.tracecompass.internal.tmf.ui.editors.TmfTableColumnUtils;
  46 import org.eclipse.tracecompass.tmf.core.TmfCommonConstants;
  47 import org.eclipse.tracecompass.tmf.core.event.aspect.ITmfEventAspect;
  48 import org.eclipse.tracecompass.tmf.core.event.aspect.TmfBaseAspects;
  49 import org.eclipse.tracecompass.tmf.core.signal.TmfSignalHandler;
  50 import org.eclipse.tracecompass.tmf.core.signal.TmfTimestampFormatUpdateSignal;
  51 import org.eclipse.tracecompass.tmf.core.signal.TmfTraceClosedSignal;
  52 import org.eclipse.tracecompass.tmf.core.signal.TmfTraceOpenedSignal;
  53 import org.eclipse.tracecompass.tmf.core.signal.TmfTraceSelectedSignal;
  54 import org.eclipse.tracecompass.tmf.core.trace.ITmfContext;
  55 import org.eclipse.tracecompass.tmf.core.trace.ITmfTrace;
  56 import org.eclipse.tracecompass.tmf.core.trace.experiment.TmfExperiment;
  57 import org.eclipse.tracecompass.tmf.ui.project.model.Messages;
  58 import org.eclipse.tracecompass.tmf.ui.project.model.TmfExperimentElement;
  59 import org.eclipse.tracecompass.tmf.ui.project.model.TmfOpenTraceHelper;
  60 import org.eclipse.tracecompass.tmf.ui.project.model.TmfProjectElement;
  61 import org.eclipse.tracecompass.tmf.ui.project.model.TmfProjectRegistry;
  62 import org.eclipse.tracecompass.tmf.ui.project.model.TmfTraceElement;
  63 import org.eclipse.tracecompass.tmf.ui.project.model.TmfTraceTypeUIUtils;
  64 import org.eclipse.tracecompass.tmf.ui.viewers.events.TmfEventsTable;
  65 import org.eclipse.ui.IEditorInput;
  66 import org.eclipse.ui.IEditorPart;
  67 import org.eclipse.ui.IEditorSite;
  68 import org.eclipse.ui.IFileEditorInput;
  69 import org.eclipse.ui.IPartListener;
  70 import org.eclipse.ui.IPropertyListener;
  71 import org.eclipse.ui.IReusableEditor;
  72 import org.eclipse.ui.IWorkbenchPart;
  73 import org.eclipse.ui.PartInitException;
  74 import org.eclipse.ui.PlatformUI;
  75 import org.eclipse.ui.ide.IGotoMarker;
  76 import org.eclipse.ui.part.FileEditorInput;
  77 import org.eclipse.ui.views.properties.IPropertySheetPage;
  78
  79 import com.google.common.collect.ImmutableSet;
  80 import com.google.common.collect.Iterables;
  81
  82 /**
  83  * Editor for TMF events
  84  *
  85  * @author Patrick Tasse
  86  */
  87 public class TmfEventsEditor extends TmfEditor implements ITmfTraceEditor, IReusableEditor, IPropertyListener, IResourceChangeListener, ISelectionProvider, ISelectionChangedListener, IPartListener, IGotoMarker {
  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     private boolean fTraceSelected;
  98     private IMarker fPendingGotoMarker;
  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 (ITmfEventsEditorConstants.EXPERIMENT_INPUT_TYPE_CONSTANTS.contains(traceTypeId)) {
 128                     // Special case: experiment bookmark resource
 129                     final TmfProjectElement project = TmfProjectRegistry.getProject(fFile.getProject(), true);
 130                     if (project == null) {
 131                         throw new PartInitException(Messages.TmfOpenTraceHelper_NoTraceType);
 132                     }
 133                     for (final TmfExperimentElement experimentElement : project.getExperimentsFolder().getExperiments()) {
 134                         if (experimentElement.getResource().equals(fFile.getParent())) {
 135                             setPartName(experimentElement.getName());
 136                             super.setSite(site);
 137                             super.setInput(fileEditorInput);
 138                             TmfOpenTraceHelper.reopenTraceFromElement(experimentElement, this);
 139                             return;
 140                         }
 141                     }
 142                 } else if (ITmfEventsEditorConstants.TRACE_INPUT_TYPE_CONSTANTS.contains(traceTypeId)) {
 143                     // Special case: trace bookmark resource
 144                     final TmfProjectElement project = TmfProjectRegistry.getProject(fFile.getProject(), true);
 145                     for (final TmfTraceElement traceElement : project.getTracesFolder().getTraces()) {
 146                         if (traceElement.getResource().equals(fFile.getParent())) {
 147                             setPartName(traceElement.getElementPath());
 148                             super.setSite(site);
 149                             super.setInput(fileEditorInput);
 150                             TmfOpenTraceHelper.reopenTraceFromElement(traceElement, this);
 151                             return;
 152                         }
 153                     }
 154                 } else {
 155                     final TmfProjectElement project = TmfProjectRegistry.getProject(fFile.getProject(), true);
 156                     for (final TmfTraceElement traceElement : project.getTracesFolder().getTraces()) {
 157                         if (traceElement.getResource().equals(fFile)) {
 158                             setPartName(traceElement.getElementPath());
 159                             super.setSite(site);
 160                             super.setInput(fileEditorInput);
 161                             TmfOpenTraceHelper.reopenTraceFromElement(traceElement, this);
 162                             return;
 163                         }
 164                     }
 165                 }
 166             } catch (final PartInitException e) {
 167                 throw e;
 168             } catch (final InvalidRegistryObjectException e) {
 169                 Activator.getDefault().logError("Error initializing TmfEventsEditor", e); //$NON-NLS-1$
 170             } catch (final CoreException e) {
 171                 Activator.getDefault().logError("Error initializing TmfEventsEditor", e); //$NON-NLS-1$
 172             }
 173         } else {
 174             throw new PartInitException("Invalid IEditorInput: " + input.getClass()); //$NON-NLS-1$
 175         }
 176         if (fTrace == null) {
 177             throw new PartInitException("Invalid IEditorInput: " + fFile.getName()); //$NON-NLS-1$
 178         }
 179         super.setSite(site);
 180         super.setInput(fileEditorInput);
 181     }
 182
 183     @Override
 184     public boolean isDirty() {
 185         return false;
 186     }
 187
 188     @Override
 189     public boolean isSaveAsAllowed() {
 190         return false;
 191     }
 192
 193     @Override
 194     public void setInput(final IEditorInput input) {
 195         super.setInput(input);
 196         firePropertyChange(IEditorPart.PROP_INPUT);
 197     }
 198
 199     @Override
 200     public void propertyChanged(final Object source, final int propId) {
 201         if (propId == IEditorPart.PROP_INPUT && getEditorInput() instanceof TmfEditorInput) {
 202             if (fTrace != null) {
 203                 broadcast(new TmfTraceClosedSignal(this, fTrace));
 204                 saveState();
 205             }
 206             fEventsTable.dispose();
 207             fFile = ((TmfEditorInput) getEditorInput()).getFile();
 208             fTrace = ((TmfEditorInput) getEditorInput()).getTrace();
 209             /* change the input to a FileEditorInput to allow open handlers to find this editor */
 210             super.setInput(new FileEditorInput(fFile));
 211             createAndInitializeTable();
 212             // The table was swapped for a new one, make sure it gets focus if
 213             // the editor is active. Otherwise, the new table will not get focus
 214             // because the editor already had focus.
 215             if (!PlatformUI.getWorkbench().isClosing() && PlatformUI.getWorkbench().getActiveWorkbenchWindow().getActivePage().getActivePart() == getSite().getPart()) {
 216                 fEventsTable.setFocus();
 217             }
 218             fParent.layout();
 219         }
 220     }
 221
 222     private void loadState() {
 223         final @Nullable String traceTypeId = fTrace.getTraceTypeId();
 224         fEventsTable.setColumnOrder(TmfTableColumnUtils.loadColumnOrder(traceTypeId));
 225         fEventsTable.setColumnWidth(TmfTableColumnUtils.loadColumnWidth(traceTypeId), TmfTableColumnUtils.loadColumnResizable(traceTypeId));
 226     }
 227
 228     private void saveState() {
 229         final @Nullable String traceTypeId = fTrace.getTraceTypeId();
 230         TmfTableColumnUtils.saveColumnOrder(traceTypeId, fEventsTable.getColumnOrder());
 231         TmfTableColumnUtils.saveColumnWidth(traceTypeId, fEventsTable.getColumnWidth());
 232         TmfTableColumnUtils.saveColumnResizability(traceTypeId, fEventsTable.getColumnResizable());
 233     }
 234
 235     @Override
 236     public void createPartControl(final Composite parent) {
 237         fParent = parent;
 238         createAndInitializeTable();
 239         addPropertyListener(this);
 240         ResourcesPlugin.getWorkspace().addResourceChangeListener(this, IResourceChangeEvent.POST_CHANGE);
 241         // we need to wrap the ISelectionProvider interface in the editor because
 242         // the events table can be replaced later while the selection changed listener
 243         // is only added once by the platform to the selection provider set here
 244         getSite().setSelectionProvider(this);
 245         getSite().getPage().addPartListener(this);
 246     }
 247
 248     private void createAndInitializeTable() {
 249         if (fTrace != null) {
 250             setPartName(fTrace.getName());
 251             fEventsTable = createEventsTable(fParent, fTrace.getCacheSize());
 252             fEventsTable.registerContextMenus(getSite());
 253             fEventsTable.addSelectionChangedListener(this);
 254             fEventsTable.setTrace(fTrace, true);
 255             fEventsTable.refreshBookmarks(fFile);
 256             loadState();
 257
 258             /* ensure start time is set */
 259             final ITmfContext context = fTrace.seekEvent(0);
 260             fTrace.getNext(context);
 261             context.dispose();
 262
 263             broadcast(new TmfTraceOpenedSignal(this, fTrace, fFile));
 264             if (fTraceSelected) {
 265                 broadcast(new TmfTraceSelectedSignal(this, fTrace));
 266             }
 267
 268             /* go to marker after trace opened */
 269             if (fPendingGotoMarker != null) {
 270                 fEventsTable.gotoMarker(fPendingGotoMarker);
 271                 fPendingGotoMarker = null;
 272             }
 273         } else {
 274             fEventsTable = new TmfEventsTable(fParent, 0);
 275             fEventsTable.addSelectionChangedListener(this);
 276         }
 277         IStatusLineManager statusLineManager = getEditorSite().getActionBars().getStatusLineManager();
 278         fEventsTable.setStatusLineManager(statusLineManager);
 279     }
 280
 281     @Override
 282     public void dispose() {
 283         if (getSite() != null) {
 284             getSite().getPage().removePartListener(this);
 285         }
 286         ResourcesPlugin.getWorkspace().removeResourceChangeListener(this);
 287         removePropertyListener(this);
 288         if (fTrace != null) {
 289             broadcast(new TmfTraceClosedSignal(this, fTrace));
 290             if (fEventsTable != null) {
 291                 saveState();
 292             }
 293         }
 294         super.dispose();
 295     }
 296
 297     /**
 298      * Create the event table
 299      *
 300      * @param parent
 301      *            The parent composite
 302      * @param cacheSize
 303      *            The cache size
 304      * @return The event table instance
 305      */
 306     protected @NonNull TmfEventsTable createEventsTable(final Composite parent, final int cacheSize) {
 307         ITmfTrace trace = fTrace;
 308
 309         /*
 310          * Check if the trace (or experiment type) defines a specific event
 311          * table in its extension point.
 312          */
 313         TmfEventsTable table = TmfTraceTypeUIUtils.getEventTable(trace, parent, cacheSize);
 314         if (table != null) {
 315             return table;
 316         }
 317
 318         /*
 319          * Use the aspects defined by the trace type (or each trace type in an
 320          * experiment) to build a table consisting of these.
 321          */
 322         Iterable<ITmfEventAspect<?>> aspects = getTraceAspects(trace);
 323         if (Iterables.isEmpty(aspects)) {
 324             /* Couldn't find any event aspects, use a default table */
 325             return new TmfEventsTable(parent, cacheSize);
 326         }
 327         return new TmfEventsTable(parent, cacheSize, aspects);
 328     }
 329
 330     /**
 331      * Get the event table for the given trace. It will be of the type defined
 332      * by the extension point if applicable, else it will be a default table
 333      * with the extension-point-defined columns (if any).
 334      *
 335      * @param trace
 336      *            The event table is for this trace
 337      * @param parent
 338      *            The parent composite of the table
 339      * @param cacheSize
 340      *            The cache size to use
 341      * @return The event table for the trace
 342      */
 343     private static @NonNull Iterable<ITmfEventAspect<?>> getTraceAspects(ITmfTrace trace) {
 344         if (trace instanceof TmfExperiment) {
 345             return getExperimentAspects((TmfExperiment) trace);
 346         }
 347         return trace.getEventAspects();
 348     }
 349
 350     /**
 351      * Get the events table for an experiment. If all traces in the experiment
 352      * are of the same type, use the same behavior as if it was one trace of
 353      * that type.
 354      *
 355      * @param experiment
 356      *            the experiment
 357      * @param parent
 358      *            the parent Composite
 359      * @param cacheSize
 360      *            the event table cache size
 361      * @return An event table of the appropriate type
 362      */
 363     private static @NonNull Iterable<ITmfEventAspect<?>> getExperimentAspects(
 364             final TmfExperiment experiment) {
 365         List<ITmfTrace> traces = experiment.getTraces();
 366         ImmutableSet.Builder<ITmfEventAspect<?>> builder = new ImmutableSet.Builder<>();
 367
 368         /* For experiments, we'll add a "trace name" aspect/column */
 369         builder.add(TmfBaseAspects.getTraceNameAspect());
 370
 371         String commonTraceType = getCommonTraceType(experiment);
 372         if (commonTraceType != null) {
 373             /*
 374              * All the traces in this experiment are of the same type, let's
 375              * just use the normal table for that type.
 376              */
 377             builder.addAll(traces.get(0).getEventAspects());
 378
 379         } else {
 380             /*
 381              * There are different trace types in the experiment, so we are
 382              * definitely using a TmfEventsTable. Aggregate the columns from all
 383              * trace types.
 384              */
 385             for (ITmfTrace trace : traces) {
 386                 Iterable<ITmfEventAspect<?>> traceAspects = trace.getEventAspects();
 387                 builder.addAll(traceAspects);
 388             }
 389         }
 390         return builder.build();
 391     }
 392
 393     /**
 394      * Check if an experiment contains traces of all the same type. If so,
 395      * returns this type as a String. If not, returns null.
 396      *
 397      * @param experiment
 398      *            The experiment
 399      * @return The common trace type if there is one, or 'null' if there are
 400      *         different types.
 401      */
 402     private static @Nullable String getCommonTraceType(TmfExperiment experiment) {
 403         String commonTraceType = null;
 404         try {
 405             for (final ITmfTrace trace : experiment.getTraces()) {
 406                 final IResource resource = trace.getResource();
 407                 if (resource == null) {
 408                     return null;
 409                 }
 410
 411                 final String traceType = resource.getPersistentProperty(TmfCommonConstants.TRACETYPE);
 412                 if ((commonTraceType != null) && !commonTraceType.equals(traceType)) {
 413                     return null;
 414                 }
 415                 commonTraceType = traceType;
 416             }
 417         } catch (CoreException e) {
 418             /*
 419              * One of the traces didn't advertise its type, we can't infer
 420              * anything.
 421              */
 422             return null;
 423         }
 424         return commonTraceType;
 425     }
 426
 427     @Override
 428     public ITmfTrace getTrace() {
 429         return fTrace;
 430     }
 431
 432     @Override
 433     public void setFocus() {
 434         fEventsTable.setFocus();
 435     }
 436
 437     @Override
 438     public <T> T getAdapter(final Class<T> adapter) {
 439         if (IGotoMarker.class.equals(adapter)) {
 440             if (fTrace == null || fEventsTable == null) {
 441                 return adapter.cast(this);
 442             }
 443             return adapter.cast(fEventsTable);
 444         } else if (IPropertySheetPage.class.equals(adapter)) {
 445             return adapter.cast(new UnsortedPropertySheetPage());
 446         }
 447         return super.getAdapter(adapter);
 448     }
 449
 450     @Override
 451     public void gotoMarker(IMarker marker) {
 452         if (fTrace == null || fEventsTable == null) {
 453             fPendingGotoMarker = marker;
 454         } else {
 455             fEventsTable.gotoMarker(marker);
 456         }
 457     }
 458
 459     @Override
 460     public void resourceChanged(final IResourceChangeEvent event) {
 461         final Set<@NonNull IMarker> added = new HashSet<>();
 462         final Set<@NonNull IMarker> removed = new HashSet<>();
 463         boolean deltaFound = false;
 464         for (final IMarkerDelta delta : event.findMarkerDeltas(IMarker.BOOKMARK, false)) {
 465             if (delta.getResource().equals(fFile)) {
 466                 if (delta.getKind() == IResourceDelta.REMOVED) {
 467                     removed.add(delta.getMarker());
 468                 } else if (delta.getKind() == IResourceDelta.ADDED) {
 469                     added.add(delta.getMarker());
 470                 }
 471                 /* this also covers IResourceDelta.CHANGED */
 472                 deltaFound = true;
 473             }
 474         }
 475         if (!deltaFound) {
 476             return;
 477         }
 478         Display.getDefault().asyncExec(new Runnable() {
 479             @Override
 480             public void run() {
 481                 if (removed.isEmpty() && added.isEmpty()) {
 482                     fEventsTable.getTable().refresh();
 483                 } else {
 484                     if (!removed.isEmpty()) {
 485                         fEventsTable.removeBookmark(Iterables.toArray(removed, IMarker.class));
 486                     }
 487                     if (!added.isEmpty()) {
 488                         fEventsTable.addBookmark(Iterables.toArray(added, IMarker.class));
 489                     }
 490                 }
 491             }
 492         });
 493     }
 494
 495     // ------------------------------------------------------------------------
 496     // ISelectionProvider
 497     // ------------------------------------------------------------------------
 498
 499     @Override
 500     public void addSelectionChangedListener(ISelectionChangedListener listener) {
 501         fSelectionChangedListeners.add(listener);
 502     }
 503
 504     @Override
 505     public ISelection getSelection() {
 506         if (fEventsTable == null) {
 507             return StructuredSelection.EMPTY;
 508         }
 509         return fEventsTable.getSelection();
 510     }
 511
 512     @Override
 513     public void removeSelectionChangedListener(ISelectionChangedListener listener) {
 514         fSelectionChangedListeners.remove(listener);
 515     }
 516
 517     @Override
 518     public void setSelection(ISelection selection) {
 519         // not implemented
 520     }
 521
 522     /**
 523      * Notifies any selection changed listeners that the viewer's selection has changed.
 524      * Only listeners registered at the time this method is called are notified.
 525      *
 526      * @param event a selection changed event
 527      *
 528      * @see ISelectionChangedListener#selectionChanged
 529      */
 530     protected void fireSelectionChanged(final SelectionChangedEvent event) {
 531         Object[] listeners = fSelectionChangedListeners.getListeners();
 532         for (int i = 0; i < listeners.length; ++i) {
 533             final ISelectionChangedListener l = (ISelectionChangedListener) listeners[i];
 534             SafeRunnable.run(new SafeRunnable() {
 535                 @Override
 536                 public void run() {
 537                     l.selectionChanged(event);
 538                 }
 539             });
 540         }
 541     }
 542
 543     // ------------------------------------------------------------------------
 544     // ISelectionChangedListener
 545     // ------------------------------------------------------------------------
 546
 547     @Override
 548     public void selectionChanged(SelectionChangedEvent event) {
 549         fireSelectionChanged(event);
 550     }
 551
 552     // ------------------------------------------------------------------------
 553     // IPartListener
 554     // ------------------------------------------------------------------------
 555
 556     @Override
 557     public void partActivated(IWorkbenchPart part) {
 558         if (part == this && !fTraceSelected) {
 559             fTraceSelected = true;
 560             if (fTrace == null) {
 561                 return;
 562             }
 563             broadcast(new TmfTraceSelectedSignal(this, fTrace));
 564         }
 565     }
 566
 567     @Override
 568     public void partBroughtToTop(IWorkbenchPart part) {
 569         if (part == this && !fTraceSelected) {
 570             fTraceSelected = true;
 571             if (fTrace == null) {
 572                 return;
 573             }
 574             broadcast(new TmfTraceSelectedSignal(this, fTrace));
 575         }
 576     }
 577
 578     @Override
 579     public void partClosed(IWorkbenchPart part) {
 580     }
 581
 582     @Override
 583     public void partDeactivated(IWorkbenchPart part) {
 584     }
 585
 586     @Override
 587     public void partOpened(IWorkbenchPart part) {
 588     }
 589
 590     // ------------------------------------------------------------------------
 591     // Global commands
 592     // ------------------------------------------------------------------------
 593
 594     /**
 595      * Add a bookmark
 596      */
 597     public void addBookmark() {
 598         fEventsTable.addBookmark(fFile);
 599     }
 600
 601
 602     // ------------------------------------------------------------------------
 603     // Signal handlers
 604     // ------------------------------------------------------------------------
 605
 606     /**
 607      * Handler for the Trace Selected signal
 608      *
 609      * @param signal The incoming signal
 610      */
 611     @TmfSignalHandler
 612     public void traceSelected(final TmfTraceSelectedSignal signal) {
 613         if ((signal.getSource() != this)) {
 614             if (signal.getTrace().equals(fTrace)) {
 615                 getSite().getPage().bringToTop(this);
 616             } else {
 617                 fTraceSelected = false;
 618             }
 619         }
 620     }
 621
 622     /**
 623      * Update the display to use the updated timestamp format
 624      *
 625      * @param signal the incoming signal
 626      */
 627     @TmfSignalHandler
 628     public void timestampFormatUpdated(TmfTimestampFormatUpdateSignal signal) {
 629         if (fEventsTable != null) {
 630             fEventsTable.refresh();
 631         }
 632     }
 633
 634 }