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.Platform;
  32 import org.eclipse.linuxtools.internal.tmf.ui.Activator;
  33 import org.eclipse.linuxtools.internal.tmf.ui.parsers.custom.CustomEventsTable;
  34 import org.eclipse.linuxtools.internal.tmf.ui.parsers.custom.CustomTxtTrace;
  35 import org.eclipse.linuxtools.internal.tmf.ui.parsers.custom.CustomXmlTrace;
  36 import org.eclipse.linuxtools.internal.tmf.ui.project.handlers.Messages;
  37 import org.eclipse.linuxtools.tmf.core.TmfCommonConstants;
  38 import org.eclipse.linuxtools.tmf.core.event.ITmfEvent;
  39 import org.eclipse.linuxtools.tmf.core.event.TmfEvent;
  40 import org.eclipse.linuxtools.tmf.core.event.TmfTimeRange;
  41 import org.eclipse.linuxtools.tmf.core.exceptions.TmfTraceException;
  42 import org.eclipse.linuxtools.tmf.core.signal.TmfSignalHandler;
  43 import org.eclipse.linuxtools.tmf.core.signal.TmfTraceSelectedSignal;
  44 import org.eclipse.linuxtools.tmf.core.trace.ITmfTrace;
  45 import org.eclipse.linuxtools.tmf.core.trace.TmfExperiment;
  46 import org.eclipse.linuxtools.tmf.core.trace.TmfTrace;
  47 import org.eclipse.linuxtools.tmf.ui.project.model.ITmfProjectModelElement;
  48 import org.eclipse.linuxtools.tmf.ui.project.model.TmfExperimentElement;
  49 import org.eclipse.linuxtools.tmf.ui.project.model.TmfNavigatorContentProvider;
  50 import org.eclipse.linuxtools.tmf.ui.project.model.TmfProjectElement;
  51 import org.eclipse.linuxtools.tmf.ui.project.model.TmfProjectRegistry;
  52 import org.eclipse.linuxtools.tmf.ui.project.model.TmfTraceElement;
  53 import org.eclipse.linuxtools.tmf.ui.project.model.TmfTraceType;
  54 import org.eclipse.linuxtools.tmf.ui.signal.TmfTraceClosedSignal;
  55 import org.eclipse.linuxtools.tmf.ui.signal.TmfTraceOpenedSignal;
  56 import org.eclipse.linuxtools.tmf.ui.signal.TmfTraceParserUpdatedSignal;
  57 import org.eclipse.linuxtools.tmf.ui.viewers.events.TmfEventsTable;
  58 import org.eclipse.swt.widgets.Composite;
  59 import org.eclipse.swt.widgets.Display;
  60 import org.eclipse.ui.IEditorInput;
  61 import org.eclipse.ui.IEditorPart;
  62 import org.eclipse.ui.IEditorSite;
  63 import org.eclipse.ui.IFileEditorInput;
  64 import org.eclipse.ui.IPropertyListener;
  65 import org.eclipse.ui.IReusableEditor;
  66 import org.eclipse.ui.PartInitException;
  67 import org.eclipse.ui.ide.IGotoMarker;
  68 import org.eclipse.ui.part.FileEditorInput;
  69 import org.osgi.framework.Bundle;
  70
  71 /**
  72  * Editor for TMF events
  73  *
  74  * @version 1.0
  75  * @author Patrick Tasse
  76  */
  77 public class TmfEventsEditor extends TmfEditor implements ITmfTraceEditor, IReusableEditor, IPropertyListener, IResourceChangeListener {
  78
  79     /** ID for this class */
  80     public static final String ID = "org.eclipse.linuxtools.tmf.ui.editors.events"; //$NON-NLS-1$
  81
  82     private TmfEventsTable fEventsTable;
  83     private IFile fFile;
  84     @SuppressWarnings("rawtypes")
  85     private ITmfTrace fTrace;
  86     private Composite fParent;
  87
  88     @Override
  89     public void doSave(final IProgressMonitor monitor) {
  90     }
  91
  92     @Override
  93     public void doSaveAs() {
  94     }
  95
  96     @SuppressWarnings({ "unchecked", "rawtypes" })
  97     @Override
  98     public void init(final IEditorSite site, IEditorInput input) throws PartInitException {
  99         if (input instanceof TmfEditorInput) {
 100             fFile = ((TmfEditorInput) input).getFile();
 101             fTrace = ((TmfEditorInput) input).getTrace();
 102             input = new FileEditorInput(fFile);
 103         } else if (input instanceof IFileEditorInput) {
 104             fFile = ((IFileEditorInput) input).getFile();
 105             if (fFile == null)
 106              {
 107                 throw new PartInitException("Invalid IFileEditorInput: " + input); //$NON-NLS-1$
 108             }
 109             try {
 110                 final String traceTypeId = fFile.getPersistentProperty(TmfCommonConstants.TRACETYPE);
 111                 if (traceTypeId == null) {
 112                     throw new PartInitException(Messages.OpenTraceHandler_NoTraceType);
 113                 }
 114                 if (traceTypeId.equals(TmfExperiment.class.getCanonicalName())) {
 115                     // Special case: experiment bookmark resource
 116                     final TmfNavigatorContentProvider ncp = new TmfNavigatorContentProvider();
 117                     ncp.getChildren(fFile.getProject()); // force the model to be populated
 118                     final TmfProjectElement project = TmfProjectRegistry.getProject(fFile.getProject());
 119                     if (project == null) {
 120                         throw new PartInitException(Messages.OpenExperimentHandler_NoTraceType);
 121                     }
 122                     for (final ITmfProjectModelElement projectElement : project.getExperimentsFolder().getChildren()) {
 123                         final String traceName = fFile.getParent().getName();
 124                         if (projectElement.getName().equals(traceName)) {
 125                             final TmfExperimentElement experimentElement = (TmfExperimentElement) projectElement;
 126                             // Instantiate the experiment's traces
 127                             final List<TmfTraceElement> traceEntries = experimentElement.getTraces();
 128                             final int nbTraces = traceEntries.size();
 129                             int cacheSize = Integer.MAX_VALUE;
 130                             final ITmfTrace<?>[] traces = new ITmfTrace[nbTraces];
 131                             for (int i = 0; i < nbTraces; i++) {
 132                                 final TmfTraceElement traceElement = traceEntries.get(i);
 133                                 final ITmfTrace trace = traceElement.instantiateTrace();
 134                                 final ITmfEvent traceEvent = traceElement.instantiateEvent();
 135                                 if ((trace == null) || (traceEvent == null)) {
 136                                     for (int j = 0; j < i; j++) {
 137                                         traces[j].dispose();
 138                                     }
 139                                     throw new PartInitException(Messages.OpenExperimentHandler_NoTraceType);
 140                                 }
 141                                 try {
 142                                     trace.initTrace(traceElement.getResource(), traceElement.getLocation().getPath(), traceEvent.getClass());
 143                                 } catch (final TmfTraceException e) {
 144                                 }
 145                                 cacheSize = Math.min(cacheSize, trace.getCacheSize());
 146                                 traces[i] = trace;
 147                             }
 148                             final TmfExperiment experiment = new TmfExperiment(ITmfEvent.class, experimentElement.getName(), traces, cacheSize) {
 149                                 @Override
 150                                 public void initTrace(IResource resource, String path, Class type) {
 151                                     super.initTrace(resource, path, type);
 152                                     getIndexer().buildIndex(getNbEvents(), TmfTimeRange.ETERNITY, false);
 153                                 }
 154                             };
 155                             experiment.setBookmarksFile(fFile);
 156                             fTrace = experiment;
 157                             experiment.initTrace(null, null, null);
 158                             break;
 159                         }
 160                     }
 161                 } else if (traceTypeId.equals(TmfTrace.class.getCanonicalName())) {
 162                     // Special case: trace bookmark resource
 163                     final TmfNavigatorContentProvider ncp = new TmfNavigatorContentProvider();
 164                     ncp.getChildren(fFile.getProject()); // force the model to be populated
 165                     final TmfProjectElement project = TmfProjectRegistry.getProject(fFile.getProject());
 166                     for (final ITmfProjectModelElement projectElement : project.getTracesFolder().getChildren()) {
 167                         final String traceName = fFile.getParent().getName();
 168                         if (projectElement.getName().equals(traceName)) {
 169                             final TmfTraceElement traceElement = (TmfTraceElement) projectElement;
 170                             // Instantiate the trace
 171                             final ITmfTrace trace = traceElement.instantiateTrace();
 172                             final ITmfEvent traceEvent = traceElement.instantiateEvent();
 173                             if ((trace == null) || (traceEvent == null)) {
 174                                 throw new PartInitException(Messages.OpenTraceHandler_NoTraceType);
 175                             }
 176                             try {
 177                                 trace.initTrace(traceElement.getResource(), traceElement.getLocation().getPath(), traceEvent.getClass());
 178                             } catch (final TmfTraceException e) {
 179                             }
 180                             fTrace = trace;
 181                             break;
 182                         }
 183                     }
 184                 } else {
 185                     final TmfNavigatorContentProvider ncp = new TmfNavigatorContentProvider();
 186                     ncp.getChildren(fFile.getProject()); // force the model to be populated
 187                     final TmfProjectElement project = TmfProjectRegistry.getProject(fFile.getProject());
 188                     for (final ITmfProjectModelElement projectElement : project.getTracesFolder().getChildren()) {
 189                         if (projectElement.getResource().equals(fFile)) {
 190                             final TmfTraceElement traceElement = (TmfTraceElement) projectElement;
 191                             // Instantiate the trace
 192                             final ITmfTrace trace = traceElement.instantiateTrace();
 193                             final ITmfEvent traceEvent = traceElement.instantiateEvent();
 194                             if ((trace == null) || (traceEvent == null)) {
 195                                 throw new PartInitException(Messages.OpenTraceHandler_NoTraceType);
 196                             }
 197                             try {
 198                                 trace.initTrace(traceElement.getResource(), traceElement.getLocation().getPath(), traceEvent.getClass());
 199                             } catch (final TmfTraceException e) {
 200                             }
 201                             fTrace = trace;
 202                             break;
 203                         }
 204                     }
 205                 }
 206             } catch (final InvalidRegistryObjectException e) {
 207                 Activator.getDefault().logError("Error initializing TmfEventsEditor", e); //$NON-NLS-1$
 208             } catch (final CoreException e) {
 209                 Activator.getDefault().logError("Error initializing TmfEventsEditor", e); //$NON-NLS-1$
 210             }
 211         }
 212         else {
 213             throw new PartInitException("Invalid IEditorInput: " + input.getClass()); //$NON-NLS-1$
 214         }
 215         if (fTrace == null)
 216          {
 217             throw new PartInitException("Invalid IEditorInput: " + fFile.getName()); //$NON-NLS-1$
 218         }
 219         super.setSite(site);
 220         super.setInput(input);
 221     }
 222
 223     @Override
 224     public boolean isDirty() {
 225         return false;
 226     }
 227
 228     @Override
 229     public boolean isSaveAsAllowed() {
 230         return false;
 231     }
 232
 233     @Override
 234     public void setInput(final IEditorInput input) {
 235         super.setInput(input);
 236         firePropertyChange(IEditorPart.PROP_INPUT);
 237     }
 238
 239     @Override
 240     public void propertyChanged(final Object source, final int propId) {
 241         if (propId == IEditorPart.PROP_INPUT) {
 242             broadcast(new TmfTraceClosedSignal(this, fTrace));
 243             fFile = ((TmfEditorInput) getEditorInput()).getFile();
 244             fTrace = ((TmfEditorInput) getEditorInput()).getTrace();
 245             super.setInput(new FileEditorInput(fFile));
 246             fEventsTable.dispose();
 247             if (fTrace != null) {
 248                 fEventsTable = createEventsTable(fParent, fTrace.getCacheSize());
 249                 fEventsTable.setTrace(fTrace, true);
 250                 fEventsTable.refreshBookmarks(fFile);
 251                 broadcast(new TmfTraceOpenedSignal(this, fTrace, fFile, fEventsTable));
 252             } else {
 253                 fEventsTable = new TmfEventsTable(fParent, 0);
 254             }
 255             fParent.layout();
 256         }
 257     }
 258
 259     @Override
 260     public void createPartControl(final Composite parent) {
 261         fParent = parent;
 262         if (fTrace != null) {
 263             setPartName(fTrace.getName());
 264             fEventsTable = createEventsTable(parent, fTrace.getCacheSize());
 265             fEventsTable.setTrace(fTrace, true);
 266             fEventsTable.refreshBookmarks(fFile);
 267             broadcast(new TmfTraceOpenedSignal(this, fTrace, fFile, fEventsTable));
 268         } else {
 269             setPartName(getEditorInput().getName());
 270             fEventsTable = new TmfEventsTable(parent, 0);
 271         }
 272         addPropertyListener(this);
 273         ResourcesPlugin.getWorkspace().addResourceChangeListener(this, IResourceChangeEvent.POST_CHANGE);
 274     }
 275
 276     @Override
 277     public void dispose() {
 278         ResourcesPlugin.getWorkspace().removeResourceChangeListener(this);
 279         removePropertyListener(this);
 280         if (fTrace != null) {
 281             broadcast(new TmfTraceClosedSignal(this, fTrace));
 282         }
 283         if (fEventsTable != null) {
 284             fEventsTable.dispose();
 285         }
 286         super.dispose();
 287     }
 288
 289     protected TmfEventsTable createEventsTable(final Composite parent, final int cacheSize) {
 290         TmfEventsTable eventsTable = getEventsTable(parent, cacheSize);
 291         if (eventsTable == null) {
 292             eventsTable = new TmfEventsTable(parent, cacheSize);
 293         }
 294         return eventsTable;
 295     }
 296
 297     private TmfEventsTable getEventsTable(final Composite parent, final int cacheSize) {
 298         if (fTrace instanceof TmfExperiment) {
 299             return getExperimentEventsTable((TmfExperiment<?>) fTrace, parent, cacheSize);
 300         }
 301         TmfEventsTable eventsTable = null;
 302         try {
 303             if (fTrace.getResource() == null) {
 304                 return null;
 305             }
 306             final String traceType = fTrace.getResource().getPersistentProperty(TmfCommonConstants.TRACETYPE);
 307             if (traceType == null) {
 308                 return null;
 309             }
 310             if (traceType.startsWith(CustomTxtTrace.class.getCanonicalName())) {
 311                 return new CustomEventsTable(((CustomTxtTrace) fTrace).getDefinition(), parent, cacheSize);
 312             }
 313             if (traceType.startsWith(CustomXmlTrace.class.getCanonicalName())) {
 314                 return new CustomEventsTable(((CustomXmlTrace) fTrace).getDefinition(), parent, cacheSize);
 315             }
 316             for (final IConfigurationElement ce : TmfTraceType.getTypeElements()) {
 317                 if (ce.getAttribute(TmfTraceType.ID_ATTR).equals(traceType)) {
 318                     final IConfigurationElement[] eventsTableTypeCE = ce.getChildren(TmfTraceType.EVENTS_TABLE_TYPE_ELEM);
 319                     if (eventsTableTypeCE.length != 1) {
 320                         break;
 321                     }
 322                     final String eventsTableType = eventsTableTypeCE[0].getAttribute(TmfTraceType.CLASS_ATTR);
 323                     if ((eventsTableType == null) || (eventsTableType.length() == 0)) {
 324                         break;
 325                     }
 326                     final Bundle bundle = Platform.getBundle(ce.getContributor().getName());
 327                     final Class<?> c = bundle.loadClass(eventsTableType);
 328                     final Class<?>[] constructorArgs = new Class[] { Composite.class, int.class };
 329                     final Constructor<?> constructor = c.getConstructor(constructorArgs);
 330                     final Object[] args = new Object[] { parent, cacheSize };
 331                     eventsTable = (TmfEventsTable) constructor.newInstance(args);
 332                     break;
 333                 }
 334             }
 335         } catch (final InvalidRegistryObjectException e) {
 336             Activator.getDefault().logError("Error getting TmfEventsTable", e); //$NON-NLS-1$
 337         } catch (final CoreException e) {
 338             Activator.getDefault().logError("Error getting TmfEventsTable", e); //$NON-NLS-1$
 339         } catch (final ClassNotFoundException e) {
 340             Activator.getDefault().logError("Error getting TmfEventsTable", e); //$NON-NLS-1$
 341         } catch (final SecurityException e) {
 342             Activator.getDefault().logError("Error getting TmfEventsTable", e); //$NON-NLS-1$
 343         } catch (final NoSuchMethodException e) {
 344             Activator.getDefault().logError("Error getting TmfEventsTable", e); //$NON-NLS-1$
 345         } catch (final IllegalArgumentException e) {
 346             Activator.getDefault().logError("Error getting TmfEventsTable", e); //$NON-NLS-1$
 347         } catch (final InstantiationException e) {
 348             Activator.getDefault().logError("Error getting TmfEventsTable", e); //$NON-NLS-1$
 349         } catch (final IllegalAccessException e) {
 350             Activator.getDefault().logError("Error getting TmfEventsTable", e); //$NON-NLS-1$
 351         } catch (final InvocationTargetException e) {
 352             Activator.getDefault().logError("Error getting TmfEventsTable", e); //$NON-NLS-1$
 353         }
 354         return eventsTable;
 355     }
 356
 357     /**
 358      * Get the events table for an experiment. If all traces in the experiment
 359      * are of the same type, use the extension point specified event table
 360      *
 361      * @param experiment
 362      *            the experiment
 363      * @param parent
 364      *            the parent Composite
 365      * @param cacheSize
 366      *            the event table cache size
 367      * @return an events table of the appropriate type
 368      */
 369     private static TmfEventsTable getExperimentEventsTable(
 370             final TmfExperiment<?> experiment, final Composite parent,
 371             final int cacheSize) {
 372         TmfEventsTable eventsTable = null;
 373         String commonTraceType = null;
 374         try {
 375             for (final ITmfTrace<?> trace : experiment.getTraces()) {
 376                 final IResource resource = trace.getResource();
 377                 if (resource == null) {
 378                     return null;
 379                 }
 380                 final String traceType = resource.getPersistentProperty(TmfCommonConstants.TRACETYPE);
 381                 if ((commonTraceType != null) && !commonTraceType.equals(traceType)) {
 382                     return null;
 383                 }
 384                 commonTraceType = traceType;
 385             }
 386             if (commonTraceType == null) {
 387                 return null;
 388             }
 389             if (commonTraceType.startsWith(CustomTxtTrace.class.getCanonicalName())) {
 390                 return new CustomEventsTable(((CustomTxtTrace) experiment.getTraces()[0]).getDefinition(), parent, cacheSize);
 391             }
 392             if (commonTraceType.startsWith(CustomXmlTrace.class.getCanonicalName())) {
 393                 return new CustomEventsTable(((CustomXmlTrace) experiment.getTraces()[0]).getDefinition(), parent, cacheSize);
 394             }
 395             for (final IConfigurationElement ce : TmfTraceType.getTypeElements()) {
 396                 if (ce.getAttribute(TmfTraceType.ID_ATTR).equals(commonTraceType)) {
 397                     final IConfigurationElement[] eventsTableTypeCE = ce.getChildren(TmfTraceType.EVENTS_TABLE_TYPE_ELEM);
 398                     if (eventsTableTypeCE.length != 1) {
 399                         break;
 400                     }
 401                     final String eventsTableType = eventsTableTypeCE[0].getAttribute(TmfTraceType.CLASS_ATTR);
 402                     if ((eventsTableType == null) || (eventsTableType.length() == 0)) {
 403                         break;
 404                     }
 405                     final Bundle bundle = Platform.getBundle(ce.getContributor().getName());
 406                     final Class<?> c = bundle.loadClass(eventsTableType);
 407                     final Class<?>[] constructorArgs = new Class[] { Composite.class, int.class };
 408                     final Constructor<?> constructor = c.getConstructor(constructorArgs);
 409                     final Object[] args = new Object[] { parent, cacheSize };
 410                     eventsTable = (TmfEventsTable) constructor.newInstance(args);
 411                     break;
 412                 }
 413             }
 414         } catch (final CoreException e) {
 415             Activator.getDefault().logError("Error getting TmfEventsTable for experiment", e); //$NON-NLS-1$
 416         } catch (final InvalidRegistryObjectException e) {
 417             Activator.getDefault().logError("Error getting TmfEventsTable for experiment", e); //$NON-NLS-1$
 418         } catch (final SecurityException e) {
 419             Activator.getDefault().logError("Error getting TmfEventsTable for experiment", e); //$NON-NLS-1$
 420         } catch (final IllegalArgumentException e) {
 421             Activator.getDefault().logError("Error getting TmfEventsTable for experiment", e); //$NON-NLS-1$
 422         } catch (final ClassNotFoundException e) {
 423             Activator.getDefault().logError("Error getting TmfEventsTable for experiment", e); //$NON-NLS-1$
 424         } catch (final NoSuchMethodException e) {
 425             Activator.getDefault().logError("Error getting TmfEventsTable for experiment", e); //$NON-NLS-1$
 426         } catch (final InstantiationException e) {
 427             Activator.getDefault().logError("Error getting TmfEventsTable for experiment", e); //$NON-NLS-1$
 428         } catch (final IllegalAccessException e) {
 429             Activator.getDefault().logError("Error getting TmfEventsTable for experiment", e); //$NON-NLS-1$
 430         } catch (final InvocationTargetException e) {
 431             Activator.getDefault().logError("Error getting TmfEventsTable for experiment", e); //$NON-NLS-1$
 432         }
 433         return eventsTable;
 434     }
 435
 436     @Override
 437     public ITmfTrace<?> getTrace() {
 438         return fTrace;
 439     }
 440
 441     @Override
 442     public IFile getBookmarksFile() {
 443         return fFile;
 444     }
 445
 446     @Override
 447     public void setFocus() {
 448         fEventsTable.setFocus();
 449         if (fTrace != null) {
 450             broadcast(new TmfTraceSelectedSignal(this, fTrace));
 451         }
 452     }
 453
 454     @Override
 455     @SuppressWarnings("rawtypes")
 456     public Object getAdapter(final Class adapter) {
 457         if (IGotoMarker.class.equals(adapter)) {
 458             return fEventsTable;
 459         }
 460         return super.getAdapter(adapter);
 461     }
 462
 463     @Override
 464     public void resourceChanged(final IResourceChangeEvent event) {
 465         for (final IMarkerDelta delta : event.findMarkerDeltas(IMarker.BOOKMARK, false)) {
 466             if (delta.getResource().equals(fFile)) {
 467                 if (delta.getKind() == IResourceDelta.REMOVED) {
 468                     final IMarker bookmark = delta.getMarker();
 469                     Display.getDefault().asyncExec(new Runnable() {
 470                         @Override
 471                         public void run() {
 472                             fEventsTable.removeBookmark(bookmark);
 473                         }
 474                     });
 475                 } else if (delta.getKind() == IResourceDelta.CHANGED) {
 476                     Display.getDefault().asyncExec(new Runnable() {
 477                         @Override
 478                         public void run() {
 479                             fEventsTable.getTable().refresh();
 480                         }
 481                     });
 482                 }
 483             }
 484         }
 485     }
 486
 487     // ------------------------------------------------------------------------
 488     // Global commands
 489     // ------------------------------------------------------------------------
 490
 491     /**
 492      * Add a bookmark
 493      */
 494     public void addBookmark() {
 495         fEventsTable.addBookmark(fFile);
 496     }
 497
 498
 499     // ------------------------------------------------------------------------
 500     // Signal handlers
 501     // ------------------------------------------------------------------------
 502
 503     /**
 504      * Handler for the Trace Parser Updated signal
 505      *
 506      * @param signal The incoming signal
 507      */
 508     @SuppressWarnings("unchecked")
 509     @TmfSignalHandler
 510     public void traceParserUpdated(final TmfTraceParserUpdatedSignal signal) {
 511         if (signal.getTraceResource().equals(fFile)) {
 512             broadcast(new TmfTraceClosedSignal(this, fTrace));
 513             try {
 514                 fTrace.getName();
 515                 fTrace = null;
 516                 final String traceTypeId = fFile.getPersistentProperty(TmfCommonConstants.TRACETYPE);
 517                 if (traceTypeId != null) {
 518                     for (final IConfigurationElement ce : TmfTraceType.getTypeElements()) {
 519                         if (traceTypeId.equals(ce.getAttribute(TmfTraceType.ID_ATTR))) {
 520                             fTrace = (ITmfTrace<?>) ce.createExecutableExtension(TmfTraceType.TRACE_TYPE_ATTR);
 521                             final ITmfEvent event = (TmfEvent) ce.createExecutableExtension(TmfTraceType.EVENT_TYPE_ATTR);
 522                             final String path = fFile.getLocationURI().getPath();
 523                             fTrace.initTrace(null, path, event.getClass());
 524                             break;
 525                         }
 526                     }
 527                 }
 528             } catch (final InvalidRegistryObjectException e) {
 529                 Activator.getDefault().logError("Error handling signal TmfTraceParserUpdatedSignal", e); //$NON-NLS-1$
 530             } catch (final TmfTraceException e) {
 531                 Activator.getDefault().logError("Error handling signal TmfTraceParserUpdatedSignal", e); //$NON-NLS-1$
 532             } catch (final CoreException e) {
 533                 Activator.getDefault().logError("Error handling signal TmfTraceParserUpdatedSignal", e); //$NON-NLS-1$
 534             }
 535             fEventsTable.dispose();
 536             if (fTrace != null) {
 537                 fEventsTable = createEventsTable(fParent, fTrace.getCacheSize());
 538                 fEventsTable.setTrace(fTrace, true);
 539                 broadcast(new TmfTraceOpenedSignal(this, fTrace, fFile, fEventsTable));
 540             } else {
 541                 fEventsTable = new TmfEventsTable(fParent, 0);
 542             }
 543             fParent.layout();
 544         }
 545     }
 546
 547     /**
 548      * Handler for the Trace Selected signal
 549      *
 550      * @param signal The incoming signal
 551      */
 552     @TmfSignalHandler
 553     public void traceSelected(final TmfTraceSelectedSignal signal) {
 554         if ((signal.getSource() != this) && signal.getTrace().equals(fTrace)) {
 555             getSite().getPage().bringToTop(this);
 556         }
 557     }
 558
 559 }