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