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