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