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