org.eclipse.linuxtools.tmf.ui/src/org/eclipse/linuxtools/tmf/ui/views/timechart/TimeChartView.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.views.timechart;
  14
  15 import java.util.ArrayList;
  16 import java.util.HashMap;
  17 import java.util.Iterator;
  18 import java.util.Map;
  19
  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.linuxtools.tmf.event.TmfEvent;
  28 import org.eclipse.linuxtools.tmf.event.TmfTimestamp;
  29 import org.eclipse.linuxtools.tmf.filter.ITmfFilter;
  30 import org.eclipse.linuxtools.tmf.signal.TmfSignalHandler;
  31 import org.eclipse.linuxtools.tmf.signal.TmfTimeSynchSignal;
  32 import org.eclipse.linuxtools.tmf.signal.TmfTraceSelectedSignal;
  33 import org.eclipse.linuxtools.tmf.signal.TmfTraceUpdatedSignal;
  34 import org.eclipse.linuxtools.tmf.trace.ITmfTrace;
  35 import org.eclipse.linuxtools.tmf.trace.TmfContext;
  36 import org.eclipse.linuxtools.tmf.ui.editors.ITmfTraceEditor;
  37 import org.eclipse.linuxtools.tmf.ui.signal.TmfTraceClosedSignal;
  38 import org.eclipse.linuxtools.tmf.ui.signal.TmfTraceOpenedSignal;
  39 import org.eclipse.linuxtools.tmf.ui.viewers.TmfViewerFactory;
  40 import org.eclipse.linuxtools.tmf.ui.viewers.events.ITmfEventsFilterListener;
  41 import org.eclipse.linuxtools.tmf.ui.viewers.events.ITmfEventsFilterProvider;
  42 import org.eclipse.linuxtools.tmf.ui.viewers.timeAnalysis.ITimeAnalysisViewer;
  43 import org.eclipse.linuxtools.tmf.ui.viewers.timeAnalysis.ITmfTimeScaleSelectionListener;
  44 import org.eclipse.linuxtools.tmf.ui.viewers.timeAnalysis.ITmfTimeSelectionListener;
  45 import org.eclipse.linuxtools.tmf.ui.viewers.timeAnalysis.TmfTimeScaleSelectionEvent;
  46 import org.eclipse.linuxtools.tmf.ui.viewers.timeAnalysis.TmfTimeSelectionEvent;
  47 import org.eclipse.linuxtools.tmf.ui.viewers.timeAnalysis.model.ITimeEvent;
  48 import org.eclipse.linuxtools.tmf.ui.viewers.timeAnalysis.model.ITmfTimeAnalysisEntry;
  49 import org.eclipse.linuxtools.tmf.ui.views.TmfView;
  50 import org.eclipse.linuxtools.tmf.ui.views.colors.ColorSetting;
  51 import org.eclipse.linuxtools.tmf.ui.views.colors.ColorSettingsManager;
  52 import org.eclipse.linuxtools.tmf.ui.views.colors.IColorSettingsListener;
  53 import org.eclipse.linuxtools.tmf.ui.views.timechart.TimeChartEvent.RankRange;
  54 import org.eclipse.swt.SWT;
  55 import org.eclipse.swt.layout.GridLayout;
  56 import org.eclipse.swt.widgets.Composite;
  57 import org.eclipse.swt.widgets.Display;
  58 import org.eclipse.ui.IEditorPart;
  59 import org.eclipse.ui.IEditorReference;
  60
  61
  62 public class TimeChartView extends TmfView implements ITmfTimeScaleSelectionListener, ITmfTimeSelectionListener, IColorSettingsListener, IResourceChangeListener, ITmfEventsFilterListener {
  63
  64     public static final String ID = "org.eclipse.linuxtools.tmf.ui.views.timechart"; //$NON-NLS-1$
  65
  66     private static final byte TIMESTAMP_SCALE = -9;
  67
  68     private int fDisplayWidth;
  69     private Composite fComposite;
  70     private ITimeAnalysisViewer fViewer;
  71     private ArrayList<TimeChartAnalysisEntry> fTimeAnalysisEntries = new ArrayList<TimeChartAnalysisEntry>();
  72     private Map<ITmfTrace, TimeChartDecorationProvider> fDecorationProviders = new HashMap<ITmfTrace, TimeChartDecorationProvider>();
  73     private ArrayList<DecorateThread> fDecorateThreads;
  74     private long fStartTime = 0;
  75     private long fStopTime = Long.MAX_VALUE;
  76
  77     public TimeChartView() {
  78         super("Time Chart"); //$NON-NLS-1$
  79         fDisplayWidth = Display.getDefault().getBounds().width;
  80     }
  81
  82     @Override
  83     public void createPartControl(Composite parent) {
  84         fComposite = new Composite(parent, SWT.NONE);
  85         GridLayout gl = new GridLayout();
  86         gl.marginWidth = 0;
  87         gl.marginHeight = 0;
  88         fComposite.setLayout(gl);
  89
  90         fViewer = TmfViewerFactory.createViewer(fComposite, new TimeChartAnalysisProvider());
  91         fViewer.groupTraces(false);
  92         fViewer.setTimeCalendarFormat(true);
  93         fViewer.setAcceptSelectionAPIcalls(true);
  94         fViewer.addWidgetTimeScaleSelectionListner(this);
  95         fViewer.addWidgetSelectionListner(this);
  96         fViewer.setMinimumItemWidth(1);
  97
  98         IEditorReference[] editorReferences = getSite().getPage().getEditorReferences();
  99         for (IEditorReference editorReference : editorReferences) {
 100             IEditorPart editor = editorReference.getEditor(false);
 101             if (editor instanceof ITmfTraceEditor) {
 102                 ITmfTrace trace = ((ITmfTraceEditor) editor).getTrace();
 103                 if (trace != null) {
 104                     IResource resource = ((ITmfTraceEditor) editor).getResource();
 105                     TimeChartAnalysisEntry timeAnalysisEntry = new TimeChartAnalysisEntry(trace, fDisplayWidth * 2);
 106                     fTimeAnalysisEntries.add(timeAnalysisEntry);
 107                     fDecorationProviders.put(trace, new TimeChartDecorationProvider(resource));
 108                     Thread thread = new ProcessTraceThread(timeAnalysisEntry);
 109                     thread.start();
 110                 }
 111             }
 112         }
 113         fViewer.display(fTimeAnalysisEntries.toArray(new TimeChartAnalysisEntry[0]));
 114
 115         fDecorateThreads = new ArrayList<DecorateThread>();
 116         ColorSettingsManager.addColorSettingsListener(this);
 117         ResourcesPlugin.getWorkspace().addResourceChangeListener(this, IResourceChangeEvent.POST_CHANGE);
 118     }
 119
 120     @Override
 121     public void dispose() {
 122         ResourcesPlugin.getWorkspace().removeResourceChangeListener(this);
 123         for (DecorateThread thread : fDecorateThreads) {
 124                 thread.cancel();
 125         }
 126         ColorSettingsManager.removeColorSettingsListener(this);
 127             super.dispose();
 128     }
 129
 130         @Override
 131     public void setFocus() {
 132         super.setFocus();
 133         fViewer.setFocus();
 134     }
 135
 136     private class ProcessTraceThread extends Thread {
 137
 138         private TimeChartAnalysisEntry fTimeAnalysisEntry;
 139
 140         public ProcessTraceThread(TimeChartAnalysisEntry timeAnalysisEntry) {
 141             super("ProcessTraceJob:"+timeAnalysisEntry.getName()); //$NON-NLS-1$
 142             fTimeAnalysisEntry = timeAnalysisEntry;
 143         }
 144
 145         @Override
 146         public void run() {
 147             updateTraceEntry(fTimeAnalysisEntry, Long.MAX_VALUE, 0, Long.MAX_VALUE);
 148         }
 149     }
 150
 151     private void updateTraceEntry(TimeChartAnalysisEntry timeAnalysisEntry, long stopRank, long startTime, long stopTime) {
 152         ITmfTrace trace = timeAnalysisEntry.getTrace();
 153         TimeChartDecorationProvider decorationProvider = fDecorationProviders.get(trace);
 154         if (decorationProvider == null) {
 155                 return; // the trace has been closed
 156         }
 157         TmfContext context = null;
 158         //TmfTimestamp lastTimestamp = null;
 159         boolean done = false;
 160         while (!done) {
 161             synchronized (timeAnalysisEntry) {
 162                 if (timeAnalysisEntry.getLastRank() >= trace.getNbEvents()) {
 163                     done = true;
 164                     break;
 165                 }
 166                 if (context == null || context.getRank() != timeAnalysisEntry.getLastRank()) {
 167                     if (timeAnalysisEntry.getLastRank() != -1) {
 168                         context = trace.seekEvent(timeAnalysisEntry.getLastRank());
 169                     } else {
 170                         //context = trace.seekLocation(null);
 171                         context = trace.seekEvent(0);
 172                     }
 173                 }
 174                 while (true) {
 175                     long rank = context.getRank();
 176                     TmfEvent event = trace.getNextEvent(context);
 177                     if (event == null) {
 178                         done = true;
 179                         break;
 180                     }
 181                     //if (!event.getTimestamp().equals(lastTimestamp)) {
 182                     TimeChartEvent timeEvent = new TimeChartEvent(timeAnalysisEntry, event, rank, decorationProvider);
 183                     if (timeEvent.getTime() >= startTime && timeEvent.getTime() <= stopTime) {
 184                         timeAnalysisEntry.addTraceEvent(timeEvent);
 185                     }
 186                     //lastTimestamp = event.getTimestamp();
 187                     //} *** commented out so that color setting priority gets set even if the event has same time
 188                     if (context.getRank() == trace.getNbEvents() || context.getRank() == stopRank) {
 189                         done = true;
 190                         break;
 191                     }
 192                     if (context.getRank() % trace.getCacheSize() == 1) {
 193                         // break for UI refresh
 194                         break;
 195                     }
 196                 }
 197                 //timeAnalysisEntry.setLastRank(Math.min(trace.getNbEvents(), stopRank));
 198                 timeAnalysisEntry.setLastRank(context.getRank());
 199             }
 200             refreshViewer(false);
 201         }
 202     }
 203
 204     private void refreshViewer(boolean resetTimeIntervals) {
 205         if (fComposite == null) {
 206             return;
 207         }
 208         final boolean reset = resetTimeIntervals;
 209         // Perform the refresh on the UI thread
 210         Display.getDefault().asyncExec(new Runnable() {
 211             @Override
 212             public void run() {
 213                 if (!fComposite.isDisposed()) {
 214                     fViewer.display(fTimeAnalysisEntries.toArray(new TimeChartAnalysisEntry[0]));
 215                     if (reset) {
 216                         fViewer.resetStartFinishTime();
 217                     }
 218                 }
 219             }
 220         });
 221     }
 222
 223     private void itemize(long startTime, long stopTime) {
 224         for (int i = 0; i < fTimeAnalysisEntries.size(); i++) {
 225             Thread thread = new ItemizeThread(fTimeAnalysisEntries.get(i), startTime, stopTime);
 226             thread.start();
 227         }
 228     }
 229
 230     private class ItemizeThread extends Thread {
 231
 232         private TimeChartAnalysisEntry fTimeAnalysisEntry;
 233         private long fStartTime;
 234         private long fStopTime;
 235         private long fMaxDuration;
 236
 237         private ItemizeThread(TimeChartAnalysisEntry timeAnalysisEntry, long startTime, long stopTime) {
 238             super("Itemize Thread:"+timeAnalysisEntry.getName()); //$NON-NLS-1$
 239             fTimeAnalysisEntry = timeAnalysisEntry;
 240             fStartTime = startTime;
 241             fStopTime = stopTime;
 242             fMaxDuration =  3 * (fStopTime - fStartTime) / fDisplayWidth;
 243         }
 244
 245         @Override
 246         public void run() {
 247             itemizeTraceEntry(fTimeAnalysisEntry);
 248         }
 249
 250         public void itemizeTraceEntry(TimeChartAnalysisEntry timeAnalysisEntry) {
 251             Iterator<ITimeEvent> iterator = timeAnalysisEntry.getTraceEventsIterator();
 252             TimeChartEvent event = null;
 253             boolean hasNext = true;
 254             while (hasNext) {
 255                 synchronized (timeAnalysisEntry) {
 256                     while (hasNext = iterator.hasNext()) {
 257                         event = (TimeChartEvent) iterator.next();
 258                         if (event.getTime() + event.getDuration() > fStartTime &&
 259                                 event.getTime() < fStopTime &&
 260                                 event.getDuration() > fMaxDuration &&
 261                                 event.getNbEvents() > 1) {
 262                             break;
 263                         }
 264                     }
 265                 }
 266                 if (hasNext) {
 267                     if (event.getItemizedEntry() == null) {
 268                         itemizeEvent(event);
 269                     } else {
 270                         itemizeTraceEntry(event.getItemizedEntry());
 271                     }
 272                 }
 273             }
 274         }
 275
 276         public void itemizeEvent(TimeChartEvent event) {
 277             synchronized (event) {
 278                 if (event.isItemizing()) {
 279                     return;
 280                 }
 281                 event.setItemizing(true);
 282             }
 283             TimeChartAnalysisEntry timeAnalysisEntry = new TimeChartAnalysisEntry(fTimeAnalysisEntry.getTrace(),
 284                     (int) Math.min(event.getNbEvents() + 1, fDisplayWidth * 2));
 285             synchronized (event.getRankRangeList()) {
 286                 for (RankRange range : event.getRankRangeList()) {
 287                         timeAnalysisEntry.setLastRank(range.getFirstRank());
 288                         updateTraceEntry(timeAnalysisEntry, range.getLastRank() + 1, event.getTime(), event.getTime() + event.getDuration());
 289                 }
 290             }
 291             event.setItemizedEntry(timeAnalysisEntry);
 292             refreshViewer(false);
 293             itemizeTraceEntry(timeAnalysisEntry);
 294             synchronized (event) {
 295                 event.setItemizing(false);
 296             }
 297         }
 298     }
 299
 300     private void redecorate() {
 301         synchronized (fDecorateThreads) {
 302                 for (DecorateThread thread : fDecorateThreads) {
 303                         thread.cancel();
 304                 }
 305                 fDecorateThreads.clear();
 306                 for (int i = 0; i < fTimeAnalysisEntries.size(); i++) {
 307                         DecorateThread thread = new DecorateThread(fTimeAnalysisEntries.get(i));
 308                         thread.start();
 309                         fDecorateThreads.add(thread);
 310                 }
 311         }
 312     }
 313
 314     private class DecorateThread extends Thread {
 315                 private volatile boolean interrupted = false;
 316         private TimeChartAnalysisEntry fTimeAnalysisEntry;
 317         private TimeChartDecorationProvider fDecorationProvider;
 318         private TmfContext fContext;
 319         private int fCount = 0;
 320
 321         private DecorateThread(TimeChartAnalysisEntry timeAnalysisEntry) {
 322             super("Decorate Thread:"+timeAnalysisEntry.getName()); //$NON-NLS-1$
 323             fTimeAnalysisEntry = timeAnalysisEntry;
 324             fDecorationProvider = fDecorationProviders.get(timeAnalysisEntry.getTrace());
 325         }
 326
 327         @Override
 328         public void run() {
 329                 resetTraceEntry(fTimeAnalysisEntry);
 330             refreshViewer(false);
 331             decorateTraceEntry(fTimeAnalysisEntry, null);
 332             refreshViewer(false);
 333                 synchronized (fDecorateThreads) {
 334                         fDecorateThreads.remove(this);
 335                 }
 336         }
 337
 338         public void resetTraceEntry(TimeChartAnalysisEntry timeAnalysisEntry) {
 339             Iterator<ITimeEvent> iterator = timeAnalysisEntry.getTraceEventsIterator();
 340             TimeChartEvent event = null;
 341             boolean hasNext = true;
 342             while (!interrupted && hasNext) {
 343                 synchronized (timeAnalysisEntry) {
 344                     while (hasNext = iterator.hasNext()) {
 345                         event = (TimeChartEvent) iterator.next();
 346                         break;
 347                     }
 348                 }
 349                 if (hasNext) {
 350                         // TODO possible concurrency problem here with ItemizeJob
 351                         event.setColorSettingPriority(ColorSettingsManager.PRIORITY_NONE);
 352                     if (event.getItemizedEntry() != null) {
 353                         resetTraceEntry(event.getItemizedEntry());
 354                     }
 355                 }
 356             }
 357         }
 358
 359         public void decorateTraceEntry(TimeChartAnalysisEntry timeAnalysisEntry, TimeChartEvent parentEvent) {
 360                 // Set max duration high to ensure iterator does not consider itemized events
 361             Iterator<ITimeEvent> iterator = timeAnalysisEntry.getTraceEventsIterator(0, Long.MAX_VALUE, Long.MAX_VALUE);
 362             TimeChartEvent event = null;
 363             int entryPriority = ColorSettingsManager.PRIORITY_NONE;
 364             boolean entryIsBookmarked = false;
 365             boolean entryIsVisible = false;
 366             boolean entryIsSearchMatch = false;
 367             boolean hasNext = true;
 368             while (!interrupted && hasNext) {
 369                 synchronized (timeAnalysisEntry) {
 370                     while (hasNext = iterator.hasNext()) {
 371                         event = (TimeChartEvent) iterator.next();
 372                         break;
 373                     }
 374                 }
 375                 if (hasNext) {
 376                         // TODO possible concurrency problem here with ItemizeJob
 377                     if (event.getItemizedEntry() == null) {
 378                         decorateEvent(event);
 379                     } else {
 380                         decorateTraceEntry(event.getItemizedEntry(), event);
 381                     }
 382                     entryPriority = Math.min(entryPriority, event.getColorSettingPriority());
 383                     entryIsBookmarked |= event.isBookmarked();
 384                     entryIsVisible |= event.isVisible();
 385                     entryIsSearchMatch |= event.isSearchMatch();
 386                     if (++fCount % timeAnalysisEntry.getTrace().getCacheSize() == 0) {
 387                         refreshViewer(false);
 388                     }
 389                 }
 390             }
 391             if (parentEvent != null) {
 392                 parentEvent.setColorSettingPriority(entryPriority);
 393                         parentEvent.setIsBookmarked(entryIsBookmarked);
 394                         parentEvent.setIsVisible(entryIsVisible);
 395                         parentEvent.setIsSearchMatch(entryIsSearchMatch);
 396             }
 397         }
 398
 399         public void decorateEvent(TimeChartEvent timeChartEvent) {
 400                 // TODO possible concurrency problem here with ItemizeJob
 401                 TimeChartAnalysisEntry timeAnalysisEntry = (TimeChartAnalysisEntry) timeChartEvent.getEntry();
 402                 ITmfTrace trace = timeAnalysisEntry.getTrace();
 403                 int priority = ColorSettingsManager.PRIORITY_NONE;
 404                 boolean isBookmarked = false;
 405                 boolean isVisible = false;
 406                 boolean isSearchMatch = false;
 407             synchronized (timeChartEvent.getRankRangeList()) {
 408                 for (RankRange range : timeChartEvent.getRankRangeList()) {
 409                         if (interrupted) return;
 410                         if (fContext == null || fContext.getRank() != range.getFirstRank()) {
 411                                 fContext = trace.seekEvent(range.getFirstRank());
 412                                 fContext.setRank(range.getFirstRank());
 413                         }
 414                     while (true) {
 415                                 if (interrupted) return;
 416                                 long rank = fContext.getRank();
 417                         TmfEvent event = trace.getNextEvent(fContext);
 418                         if (event == null) {
 419                             break;
 420                         }
 421                         long eventTime = event.getTimestamp().synchronize(0, (byte) -9).getValue();
 422                         if (eventTime >= timeChartEvent.getTime() && eventTime <= timeChartEvent.getTime() + timeChartEvent.getDuration()) {
 423                                 priority = Math.min(priority, ColorSettingsManager.getColorSettingPriority(event));
 424                         }
 425                         isBookmarked |= fDecorationProvider.isBookmark(rank);
 426                         isVisible |= fDecorationProvider.isVisible(event);
 427                         isSearchMatch |= fDecorationProvider.isSearchMatch(event);
 428                         if (fContext.getRank() > range.getLastRank()) {
 429                                 break;
 430                         }
 431                     }
 432                 }
 433             }
 434             timeChartEvent.setColorSettingPriority(priority);
 435             timeChartEvent.setIsBookmarked(isBookmarked);
 436             timeChartEvent.setIsVisible(isVisible);
 437             timeChartEvent.setIsSearchMatch(isSearchMatch);
 438         }
 439
 440                 public void cancel() {
 441                         interrupted = true;
 442                 }
 443     }
 444
 445     // ------------------------------------------------------------------------
 446     // Listeners
 447     // ------------------------------------------------------------------------
 448
 449     @Override
 450     public void tsfTmProcessTimeScaleEvent(TmfTimeScaleSelectionEvent event) {
 451         fStartTime = event.getTime0();
 452         fStopTime = event.getTime1();
 453         itemize(fStartTime, fStopTime);
 454     }
 455
 456     @Override
 457     public void tsfTmProcessSelEvent(TmfTimeSelectionEvent event) {
 458         ITmfTimeAnalysisEntry timeAnalysisEntry = null;
 459         if (event.getSelection() instanceof TimeChartAnalysisEntry) {
 460             timeAnalysisEntry = (TimeChartAnalysisEntry) event.getSelection();
 461         } else if (event.getSelection() instanceof TimeChartEvent) {
 462             timeAnalysisEntry = ((TimeChartEvent) event.getSelection()).getEntry();
 463         }
 464         if (timeAnalysisEntry instanceof TimeChartAnalysisEntry) {
 465             broadcast(new TmfTraceSelectedSignal(this, ((TimeChartAnalysisEntry) timeAnalysisEntry).getTrace()));
 466         }
 467         broadcast(new TmfTimeSynchSignal(this, new TmfTimestamp(event.getSelectedTime(), TIMESTAMP_SCALE)));
 468     }
 469
 470         @Override
 471     public void colorSettingsChanged(ColorSetting[] colorSettings) {
 472                 redecorate();
 473     }
 474
 475     @Override
 476     public void resourceChanged(IResourceChangeEvent event) {
 477                 for (IMarkerDelta delta : event.findMarkerDeltas(IMarker.BOOKMARK, false)) {
 478                         for (TimeChartDecorationProvider provider : fDecorationProviders.values()) {
 479                                 if (delta.getResource().equals(provider.getResource())) {
 480                                         if (delta.getKind() == IResourceDelta.CHANGED && delta.getMarker().getAttribute(IMarker.LOCATION, -1) != -1) {
 481                                                 provider.refreshBookmarks();
 482                                         } else if (delta.getKind() == IResourceDelta.REMOVED) {
 483                                                 provider.refreshBookmarks();
 484                                         }
 485                                 }
 486                         }
 487                 }
 488                 redecorate();
 489     }
 490
 491         @Override
 492     public void filterApplied(ITmfFilter filter, ITmfTrace trace) {
 493                 TimeChartDecorationProvider decorationProvider = fDecorationProviders.get(trace);
 494                 decorationProvider.filterApplied(filter);
 495                 redecorate();
 496     }
 497
 498         @Override
 499     public void searchApplied(ITmfFilter filter, ITmfTrace trace) {
 500                 TimeChartDecorationProvider decorationProvider = fDecorationProviders.get(trace);
 501                 decorationProvider.searchApplied(filter);
 502                 redecorate();
 503     }
 504
 505     // ------------------------------------------------------------------------
 506     // Signal handlers
 507     // ------------------------------------------------------------------------
 508
 509         @TmfSignalHandler
 510     public void traceOpened(TmfTraceOpenedSignal signal) {
 511         if (fTimeAnalysisEntries == null) return;
 512         final ITmfTrace trace = signal.getTrace();
 513         final IResource resource = signal.getResource();
 514         final ITmfEventsFilterProvider eventsFilterProvider = signal.getEventsFilterProvider();
 515         TimeChartAnalysisEntry timeAnalysisEntry = null;
 516         for (int i = 0; i < fTimeAnalysisEntries.size(); i++) {
 517             if (fTimeAnalysisEntries.get(i).getTrace().equals(trace)) {
 518                 timeAnalysisEntry = fTimeAnalysisEntries.get(i);
 519                 break;
 520             }
 521         }
 522         if (timeAnalysisEntry == null) {
 523             timeAnalysisEntry = new TimeChartAnalysisEntry(trace, fDisplayWidth * 2);
 524             fTimeAnalysisEntries.add(timeAnalysisEntry);
 525             fDecorationProviders.put(trace, new TimeChartDecorationProvider(resource));
 526             Thread thread = new ProcessTraceThread(timeAnalysisEntry);
 527             thread.start();
 528         }
 529         refreshViewer(true);
 530         if (eventsFilterProvider != null) {
 531                 eventsFilterProvider.addEventsFilterListener(this);
 532         }
 533     }
 534
 535     @TmfSignalHandler
 536     public void traceClosed(TmfTraceClosedSignal signal) {
 537         if (fTimeAnalysisEntries == null) return;
 538         final ITmfTrace trace = signal.getTrace();
 539         for (int i = 0; i < fTimeAnalysisEntries.size(); i++) {
 540             if (fTimeAnalysisEntries.get(i).getTrace().equals(trace)) {
 541                 fTimeAnalysisEntries.remove(i);
 542                 fDecorationProviders.remove(trace);
 543                 refreshViewer(true);
 544                 break;
 545             }
 546         }
 547     }
 548
 549     @TmfSignalHandler
 550     public void traceSelected(TmfTraceSelectedSignal signal) {
 551         if (signal.getSource() != this && fTimeAnalysisEntries != null) {
 552             ITmfTrace trace = signal.getTrace();
 553             for (int i = 0; i < fTimeAnalysisEntries.size(); i++) {
 554                 if (fTimeAnalysisEntries.get(i).getTrace().equals(trace)) {
 555                     fViewer.setSelectedTrace(fTimeAnalysisEntries.get(i));
 556                     break;
 557                 }
 558             }
 559         }
 560     }
 561
 562     @TmfSignalHandler
 563     public void traceUpdated(TmfTraceUpdatedSignal signal) {
 564         if (fTimeAnalysisEntries == null) return;
 565         final ITmfTrace trace = signal.getTrace();
 566         for (int i = 0; i < fTimeAnalysisEntries.size(); i++) {
 567             TimeChartAnalysisEntry timeAnalysisEntry = fTimeAnalysisEntries.get(i);
 568             if (timeAnalysisEntry.getTrace().equals(trace)) {
 569                 updateTraceEntry(timeAnalysisEntry, Long.MAX_VALUE, 0, Long.MAX_VALUE);
 570                 break;
 571             }
 572         }
 573     }
 574
 575     @TmfSignalHandler
 576     public void currentTimeUpdated(TmfTimeSynchSignal signal) {
 577         long time = signal.getCurrentTime().synchronize(0, TIMESTAMP_SCALE).getValue();
 578         fViewer.setSelectedTime(time, true, this);
 579     }
 580
 581 }