tmf/org.eclipse.tracecompass.tmf.ui/src/org/eclipse/tracecompass/tmf/ui/views/timechart/TimeChartView.java

   1 /*******************************************************************************
   2  * Copyright (c) 2010, 2016 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.tracecompass.tmf.ui.views.timechart;
  14
  15 import java.util.ArrayList;
  16 import java.util.HashMap;
  17 import java.util.Iterator;
  18 import java.util.List;
  19 import java.util.Map;
  20
  21 import org.eclipse.core.resources.IFile;
  22 import org.eclipse.core.resources.IMarker;
  23 import org.eclipse.core.resources.IMarkerDelta;
  24 import org.eclipse.core.resources.IResourceChangeEvent;
  25 import org.eclipse.core.resources.IResourceChangeListener;
  26 import org.eclipse.core.resources.IResourceDelta;
  27 import org.eclipse.core.resources.ResourcesPlugin;
  28 import org.eclipse.jface.action.IStatusLineManager;
  29 import org.eclipse.swt.SWT;
  30 import org.eclipse.swt.widgets.Composite;
  31 import org.eclipse.swt.widgets.Display;
  32 import org.eclipse.tracecompass.tmf.core.event.ITmfEvent;
  33 import org.eclipse.tracecompass.tmf.core.resources.ITmfMarker;
  34 import org.eclipse.tracecompass.tmf.core.signal.TmfEventFilterAppliedSignal;
  35 import org.eclipse.tracecompass.tmf.core.signal.TmfEventSearchAppliedSignal;
  36 import org.eclipse.tracecompass.tmf.core.signal.TmfSelectionRangeUpdatedSignal;
  37 import org.eclipse.tracecompass.tmf.core.signal.TmfSignalHandler;
  38 import org.eclipse.tracecompass.tmf.core.signal.TmfTraceClosedSignal;
  39 import org.eclipse.tracecompass.tmf.core.signal.TmfTraceOpenedSignal;
  40 import org.eclipse.tracecompass.tmf.core.signal.TmfTraceSelectedSignal;
  41 import org.eclipse.tracecompass.tmf.core.signal.TmfTraceUpdatedSignal;
  42 import org.eclipse.tracecompass.tmf.core.signal.TmfWindowRangeUpdatedSignal;
  43 import org.eclipse.tracecompass.tmf.core.timestamp.ITmfTimestamp;
  44 import org.eclipse.tracecompass.tmf.core.timestamp.TmfTimeRange;
  45 import org.eclipse.tracecompass.tmf.core.timestamp.TmfTimestamp;
  46 import org.eclipse.tracecompass.tmf.core.trace.ITmfContext;
  47 import org.eclipse.tracecompass.tmf.core.trace.ITmfTrace;
  48 import org.eclipse.tracecompass.tmf.core.trace.TmfTraceContext;
  49 import org.eclipse.tracecompass.tmf.core.trace.TmfTraceManager;
  50 import org.eclipse.tracecompass.tmf.ui.signal.TmfTimeViewAlignmentInfo;
  51 import org.eclipse.tracecompass.tmf.ui.views.ITmfTimeAligned;
  52 import org.eclipse.tracecompass.tmf.ui.views.TmfView;
  53 import org.eclipse.tracecompass.tmf.ui.views.colors.ColorSetting;
  54 import org.eclipse.tracecompass.tmf.ui.views.colors.ColorSettingsManager;
  55 import org.eclipse.tracecompass.tmf.ui.views.colors.IColorSettingsListener;
  56 import org.eclipse.tracecompass.tmf.ui.views.timechart.TimeChartEvent.RankRange;
  57 import org.eclipse.tracecompass.tmf.ui.widgets.timegraph.ITimeGraphPresentationProvider;
  58 import org.eclipse.tracecompass.tmf.ui.widgets.timegraph.ITimeGraphRangeListener;
  59 import org.eclipse.tracecompass.tmf.ui.widgets.timegraph.ITimeGraphSelectionListener;
  60 import org.eclipse.tracecompass.tmf.ui.widgets.timegraph.ITimeGraphTimeListener;
  61 import org.eclipse.tracecompass.tmf.ui.widgets.timegraph.TimeGraphRangeUpdateEvent;
  62 import org.eclipse.tracecompass.tmf.ui.widgets.timegraph.TimeGraphSelectionEvent;
  63 import org.eclipse.tracecompass.tmf.ui.widgets.timegraph.TimeGraphTimeEvent;
  64 import org.eclipse.tracecompass.tmf.ui.widgets.timegraph.TimeGraphViewer;
  65 import org.eclipse.tracecompass.tmf.ui.widgets.timegraph.model.ITimeEvent;
  66 import org.eclipse.tracecompass.tmf.ui.widgets.timegraph.model.ITimeGraphEntry;
  67 import org.eclipse.tracecompass.tmf.ui.widgets.timegraph.widgets.Utils.TimeFormat;
  68
  69 /**
  70  * Generic Time Chart view, which is similar to a Gantt chart for trace analysis
  71  *
  72  * @version 1.0
  73  * @author Patrick Tasse
  74  */
  75 public class TimeChartView extends TmfView implements ITimeGraphRangeListener, ITimeGraphSelectionListener, ITimeGraphTimeListener, IColorSettingsListener, IResourceChangeListener, ITmfTimeAligned {
  76
  77     /** TimeChartView's ID */
  78     public static final String ID = "org.eclipse.linuxtools.tmf.ui.views.timechart"; //$NON-NLS-1$
  79
  80     private final int fDisplayWidth;
  81     private TimeGraphViewer fViewer;
  82     private final List<TimeChartAnalysisEntry> fTimeAnalysisEntries = new ArrayList<>();
  83     private final Map<ITmfTrace, TimeChartDecorationProvider> fDecorationProviders = new HashMap<>();
  84     private final List<DecorateThread> fDecorateThreads = new ArrayList<>();
  85     private long fStartTime = 0;
  86     private long fStopTime = Long.MAX_VALUE;
  87     private boolean fRefreshBusy = false;
  88     private boolean fRefreshPending = false;
  89     private boolean fRedrawBusy = false;
  90     private boolean fRedrawPending = false;
  91     private final Object fSyncObj = new Object();
  92     private ITimeGraphPresentationProvider fPresentationProvider;
  93
  94     /**
  95      * Default constructor
  96      */
  97     public TimeChartView() {
  98         super("Time Chart"); //$NON-NLS-1$
  99         fDisplayWidth = Display.getDefault().getBounds().width;
 100     }
 101
 102     @Override
 103     public void createPartControl(Composite parent) {
 104         super.createPartControl(parent);
 105         fViewer = new TimeGraphViewer(parent, SWT.NONE);
 106         fPresentationProvider = new TimeChartAnalysisProvider();
 107         fViewer.setTimeGraphProvider(fPresentationProvider);
 108         fViewer.setTimeFormat(TimeFormat.CALENDAR);
 109         fViewer.addTimeListener(this);
 110         fViewer.addRangeListener(this);
 111         fViewer.addSelectionListener(this);
 112         fViewer.setMinimumItemWidth(1);
 113         fViewer.getTimeGraphControl().setBlendSubPixelEvents(true);
 114
 115         IStatusLineManager statusLineManager = getViewSite().getActionBars().getStatusLineManager();
 116         fViewer.getTimeGraphControl().setStatusLineManager(statusLineManager);
 117
 118         for (ITmfTrace trace : TmfTraceManager.getInstance().getOpenedTraces()) {
 119             IFile bookmarksFile = TmfTraceManager.getInstance().getTraceEditorFile(trace);
 120             TimeChartAnalysisEntry timeAnalysisEntry = new TimeChartAnalysisEntry(trace, fDisplayWidth * 2);
 121             fTimeAnalysisEntries.add(timeAnalysisEntry);
 122             fDecorationProviders.put(trace, new TimeChartDecorationProvider(bookmarksFile));
 123             Thread thread = new ProcessTraceThread(timeAnalysisEntry);
 124             thread.start();
 125         }
 126         fViewer.setInput(fTimeAnalysisEntries.toArray(new TimeChartAnalysisEntry[0]));
 127
 128         ColorSettingsManager.addColorSettingsListener(this);
 129         ResourcesPlugin.getWorkspace().addResourceChangeListener(this, IResourceChangeEvent.POST_CHANGE);
 130     }
 131
 132     @Override
 133     public void dispose() {
 134         ResourcesPlugin.getWorkspace().removeResourceChangeListener(this);
 135         for (DecorateThread thread : fDecorateThreads) {
 136             thread.cancel();
 137         }
 138         ColorSettingsManager.removeColorSettingsListener(this);
 139         super.dispose();
 140     }
 141
 142     @Override
 143     public void setFocus() {
 144         fViewer.setFocus();
 145     }
 146
 147     private class ProcessTraceThread extends Thread {
 148
 149         private final TimeChartAnalysisEntry fTimeAnalysisEntry;
 150
 151         public ProcessTraceThread(TimeChartAnalysisEntry timeAnalysisEntry) {
 152             super("ProcessTraceJob:" + timeAnalysisEntry.getName()); //$NON-NLS-1$
 153             fTimeAnalysisEntry = timeAnalysisEntry;
 154         }
 155
 156         @Override
 157         public void run() {
 158             TmfTimeRange range = TmfTraceManager.getInstance().getCurrentTraceContext().getWindowRange();
 159
 160             updateTraceEntry(fTimeAnalysisEntry, Long.MAX_VALUE,
 161                     range.getStartTime().toNanos(),
 162                     range.getEndTime().toNanos());
 163         }
 164     }
 165
 166     private void updateTraceEntry(TimeChartAnalysisEntry timeAnalysisEntry, long stopRank, long startTime, long stopTime) {
 167         ITmfTrace trace = timeAnalysisEntry.getTrace();
 168         TimeChartDecorationProvider decorationProvider = fDecorationProviders.get(trace);
 169         if (decorationProvider == null) {
 170             return; // the trace has been closed
 171         }
 172         ITmfContext context = null;
 173         // TmfTimestamp lastTimestamp = null;
 174         boolean done = false;
 175         while (!done) {
 176             synchronized (timeAnalysisEntry) {
 177                 if (timeAnalysisEntry.getLastRank() >= trace.getNbEvents()) {
 178                     done = true;
 179                     break;
 180                 }
 181                 if (context == null || context.getRank() != timeAnalysisEntry.getLastRank()) {
 182                     if (context != null) {
 183                         context.dispose();
 184                     }
 185                     if (timeAnalysisEntry.getLastRank() != -1) {
 186                         context = trace.seekEvent(timeAnalysisEntry.getLastRank());
 187                     } else {
 188                         // context = trace.seekLocation(null);
 189                         context = trace.seekEvent(0);
 190                     }
 191                 }
 192                 while (true) {
 193                     long rank = context.getRank();
 194                     ITmfEvent event = trace.getNext(context);
 195                     if (event == null) {
 196                         done = true;
 197                         break;
 198                     }
 199                     // if (!event.getTimestamp().equals(lastTimestamp)) {
 200                     TimeChartEvent timeEvent = new TimeChartEvent(timeAnalysisEntry, event, rank, decorationProvider);
 201                     if (timeEvent.getTime() >= startTime && timeEvent.getTime() <= stopTime) {
 202                         timeAnalysisEntry.addTraceEvent(timeEvent);
 203                     }
 204                     // lastTimestamp = event.getTimestamp();
 205                     // } *** commented out so that color setting priority gets
 206                     // set even if the event has same time
 207                     if (context.getRank() == trace.getNbEvents() || context.getRank() == stopRank) {
 208                         done = true;
 209                         break;
 210                     }
 211                     if (context.getRank() % trace.getCacheSize() == 1) {
 212                         // break for UI refresh
 213                         break;
 214                     }
 215                 }
 216                 // timeAnalysisEntry.setLastRank(Math.min(trace.getNbEvents(),
 217                 // stopRank));
 218                 timeAnalysisEntry.setLastRank(context.getRank());
 219             }
 220             redrawViewer(true);
 221         }
 222         if (context != null) {
 223             context.dispose();
 224         }
 225     }
 226
 227     private void refreshViewer() {
 228         synchronized (fSyncObj) {
 229             if (fRefreshBusy) {
 230                 fRefreshPending = true;
 231                 return;
 232             }
 233             fRefreshBusy = true;
 234         }
 235         // Perform the refresh on the UI thread
 236         Display.getDefault().asyncExec(new Runnable() {
 237             @Override
 238             public void run() {
 239                 if (fViewer.getControl().isDisposed()) {
 240                     return;
 241                 }
 242                 fViewer.setInput(fTimeAnalysisEntries.toArray(new TimeChartAnalysisEntry[0]));
 243                 fViewer.resetStartFinishTime();
 244                 synchronized (fSyncObj) {
 245                     fRefreshBusy = false;
 246                     if (fRefreshPending) {
 247                         fRefreshPending = false;
 248                         refreshViewer();
 249                     }
 250                 }
 251             }
 252         });
 253     }
 254
 255     private void redrawViewer(boolean resetTimeIntervals) {
 256         synchronized (fSyncObj) {
 257             if (fRedrawBusy) {
 258                 fRedrawPending = true;
 259                 return;
 260             }
 261             fRedrawBusy = true;
 262         }
 263         final boolean reset = resetTimeIntervals;
 264         // Perform the refresh on the UI thread
 265         Display.getDefault().asyncExec(new Runnable() {
 266             @Override
 267             public void run() {
 268                 if (fViewer.getControl().isDisposed()) {
 269                     return;
 270                 }
 271                 if (reset) {
 272                     fViewer.setTimeRange(fTimeAnalysisEntries.toArray(new TimeChartAnalysisEntry[0]));
 273                     fViewer.setTimeBounds();
 274                 }
 275                 fViewer.getControl().redraw();
 276                 fViewer.getControl().update();
 277                 synchronized (fSyncObj) {
 278                     fRedrawBusy = false;
 279                     if (fRedrawPending) {
 280                         fRedrawPending = false;
 281                         redrawViewer(reset);
 282                     }
 283                 }
 284             }
 285         });
 286     }
 287
 288     private void itemize(long startTime, long stopTime) {
 289         for (int i = 0; i < fTimeAnalysisEntries.size(); i++) {
 290             Thread thread = new ItemizeThread(fTimeAnalysisEntries.get(i), startTime, stopTime);
 291             thread.start();
 292         }
 293     }
 294
 295     private class ItemizeThread extends Thread {
 296
 297         private final TimeChartAnalysisEntry fTimeAnalysisEntry;
 298         private final long startTime;
 299         private final long stopTime;
 300         private final long fMaxDuration;
 301
 302         private ItemizeThread(TimeChartAnalysisEntry timeAnalysisEntry, long startTime, long stopTime) {
 303             super("Itemize Thread:" + timeAnalysisEntry.getName()); //$NON-NLS-1$
 304             fTimeAnalysisEntry = timeAnalysisEntry;
 305             this.startTime = startTime;
 306             this.stopTime = stopTime;
 307             fMaxDuration = 3 * (stopTime - startTime) / fDisplayWidth;
 308         }
 309
 310         @Override
 311         public void run() {
 312             itemizeTraceEntry(fTimeAnalysisEntry);
 313         }
 314
 315         public void itemizeTraceEntry(TimeChartAnalysisEntry timeAnalysisEntry) {
 316             Iterator<ITimeEvent> iterator = timeAnalysisEntry.getTimeEventsIterator();
 317             TimeChartEvent event = null;
 318             boolean hasNext = true;
 319             while (hasNext) {
 320                 synchronized (timeAnalysisEntry) {
 321                     while ((hasNext = iterator.hasNext()) == true) {
 322                         event = (TimeChartEvent) iterator.next();
 323                         if (event.getTime() + event.getDuration() > startTime && event.getTime() < stopTime && event.getDuration() > fMaxDuration
 324                                 && event.getNbEvents() > 1) {
 325                             break;
 326                         }
 327                     }
 328                 }
 329                 if (hasNext && event != null) {
 330                     if (event.getItemizedEntry() == null) {
 331                         itemizeEvent(event);
 332                     } else {
 333                         itemizeTraceEntry(event.getItemizedEntry());
 334                     }
 335                 }
 336             }
 337         }
 338
 339         public void itemizeEvent(TimeChartEvent event) {
 340             synchronized (event) {
 341                 if (event.isItemizing()) {
 342                     return;
 343                 }
 344                 event.setItemizing(true);
 345             }
 346             TimeChartAnalysisEntry timeAnalysisEntry = new TimeChartAnalysisEntry(fTimeAnalysisEntry.getTrace(), (int) Math.min(
 347                     event.getNbEvents() + 1, fDisplayWidth * 2));
 348             synchronized (event.getRankRangeList()) {
 349                 for (RankRange range : event.getRankRangeList()) {
 350                     timeAnalysisEntry.setLastRank(range.getFirstRank());
 351                     updateTraceEntry(timeAnalysisEntry, range.getLastRank() + 1, event.getTime(), event.getTime() + event.getDuration());
 352                 }
 353             }
 354             event.setItemizedEntry(timeAnalysisEntry);
 355             redrawViewer(false);
 356             itemizeTraceEntry(timeAnalysisEntry);
 357             synchronized (event) {
 358                 event.setItemizing(false);
 359             }
 360         }
 361     }
 362
 363     private void redecorate() {
 364         synchronized (fDecorateThreads) {
 365             for (DecorateThread thread : fDecorateThreads) {
 366                 thread.cancel();
 367             }
 368             fDecorateThreads.clear();
 369             for (int i = 0; i < fTimeAnalysisEntries.size(); i++) {
 370                 DecorateThread thread = new DecorateThread(fTimeAnalysisEntries.get(i));
 371                 thread.start();
 372                 fDecorateThreads.add(thread);
 373             }
 374         }
 375     }
 376
 377     private class DecorateThread extends Thread {
 378         private volatile boolean interrupted = false;
 379         private final TimeChartAnalysisEntry fTimeAnalysisEntry;
 380         private final TimeChartDecorationProvider fDecorationProvider;
 381         private ITmfContext fContext;
 382         private int fCount = 0;
 383
 384         private DecorateThread(TimeChartAnalysisEntry timeAnalysisEntry) {
 385             super("Decorate Thread:" + timeAnalysisEntry.getName()); //$NON-NLS-1$
 386             fTimeAnalysisEntry = timeAnalysisEntry;
 387             fDecorationProvider = fDecorationProviders.get(timeAnalysisEntry.getTrace());
 388         }
 389
 390         @Override
 391         public void run() {
 392             resetTraceEntry(fTimeAnalysisEntry);
 393             redrawViewer(false);
 394             decorateTraceEntry(fTimeAnalysisEntry, null);
 395             redrawViewer(false);
 396             synchronized (fDecorateThreads) {
 397                 fDecorateThreads.remove(this);
 398             }
 399             if (fContext != null) {
 400                 fContext.dispose();
 401             }
 402         }
 403
 404         public void resetTraceEntry(TimeChartAnalysisEntry timeAnalysisEntry) {
 405             Iterator<ITimeEvent> iterator = timeAnalysisEntry.getTimeEventsIterator();
 406             TimeChartEvent event = null;
 407             boolean hasNext = true;
 408             while (!interrupted && hasNext) {
 409                 synchronized (timeAnalysisEntry) {
 410                     while ((hasNext = iterator.hasNext()) == true) {
 411                         event = (TimeChartEvent) iterator.next();
 412                         break;
 413                     }
 414                 }
 415                 if (hasNext && event != null) {
 416                     // TODO possible concurrency problem here with ItemizeJob
 417                     event.setColorSettingPriority(ColorSettingsManager.PRIORITY_NONE);
 418                     if (event.getItemizedEntry() != null) {
 419                         resetTraceEntry(event.getItemizedEntry());
 420                     }
 421                 }
 422             }
 423         }
 424
 425         public void decorateTraceEntry(TimeChartAnalysisEntry timeAnalysisEntry, TimeChartEvent parentEvent) {
 426             // Set max duration high to ensure iterator does not consider
 427             // itemized events
 428             Iterator<ITimeEvent> iterator = timeAnalysisEntry.getTimeEventsIterator(0, Long.MAX_VALUE, Long.MAX_VALUE);
 429             TimeChartEvent event = null;
 430             int entryPriority = ColorSettingsManager.PRIORITY_NONE;
 431             boolean entryIsBookmarked = false;
 432             boolean entryIsVisible = false;
 433             boolean entryIsSearchMatch = false;
 434             boolean hasNext = true;
 435             while (!interrupted && hasNext) {
 436                 synchronized (timeAnalysisEntry) {
 437                     while ((hasNext = iterator.hasNext()) == true) {
 438                         event = (TimeChartEvent) iterator.next();
 439                         break;
 440                     }
 441                 }
 442                 if (hasNext && event != null) {
 443                     // TODO possible concurrency problem here with ItemizeJob
 444                     if (event.getItemizedEntry() == null) {
 445                         decorateEvent(event);
 446                     } else {
 447                         decorateTraceEntry(event.getItemizedEntry(), event);
 448                     }
 449                     entryPriority = Math.min(entryPriority, event.getColorSettingPriority());
 450                     entryIsBookmarked |= event.isBookmarked();
 451                     entryIsVisible |= event.isVisible();
 452                     entryIsSearchMatch |= event.isSearchMatch();
 453                     if (++fCount % timeAnalysisEntry.getTrace().getCacheSize() == 0) {
 454                         redrawViewer(false);
 455                     }
 456                 }
 457             }
 458             if (parentEvent != null) {
 459                 parentEvent.setColorSettingPriority(entryPriority);
 460                 parentEvent.setIsBookmarked(entryIsBookmarked);
 461                 parentEvent.setIsVisible(entryIsVisible);
 462                 parentEvent.setIsSearchMatch(entryIsSearchMatch);
 463             }
 464         }
 465
 466         public void decorateEvent(TimeChartEvent timeChartEvent) {
 467             // TODO possible concurrency problem here with ItemizeJob
 468             TimeChartAnalysisEntry timeAnalysisEntry = (TimeChartAnalysisEntry) timeChartEvent.getEntry();
 469             ITmfTrace trace = timeAnalysisEntry.getTrace();
 470             int priority = ColorSettingsManager.PRIORITY_NONE;
 471             boolean isBookmarked = false;
 472             boolean isVisible = false;
 473             boolean isSearchMatch = false;
 474             synchronized (timeChartEvent.getRankRangeList()) {
 475                 for (RankRange range : timeChartEvent.getRankRangeList()) {
 476                     if (interrupted) {
 477                         return;
 478                     }
 479                     if (fContext == null || fContext.getRank() != range.getFirstRank()) {
 480                         if (fContext != null) {
 481                             fContext.dispose();
 482                         }
 483                         fContext = trace.seekEvent(range.getFirstRank());
 484                         fContext.setRank(range.getFirstRank());
 485                     }
 486                     while (true) {
 487                         if (interrupted) {
 488                             return;
 489                         }
 490                         long rank = fContext.getRank();
 491                         ITmfEvent event = trace.getNext(fContext);
 492                         if (event == null) {
 493                             break;
 494                         }
 495                         long eventTime = event.getTimestamp().toNanos();
 496                         if (eventTime >= timeChartEvent.getTime() && eventTime <= timeChartEvent.getTime() + timeChartEvent.getDuration()) {
 497                             priority = Math.min(priority, ColorSettingsManager.getColorSettingPriority(event));
 498                         }
 499                         isBookmarked |= fDecorationProvider.isBookmark(rank);
 500                         isVisible |= fDecorationProvider.isVisible(event);
 501                         isSearchMatch |= fDecorationProvider.isSearchMatch(event);
 502                         if (fContext.getRank() > range.getLastRank()) {
 503                             break;
 504                         }
 505                     }
 506                 }
 507             }
 508             timeChartEvent.setColorSettingPriority(priority);
 509             timeChartEvent.setIsBookmarked(isBookmarked);
 510             timeChartEvent.setIsVisible(isVisible);
 511             timeChartEvent.setIsSearchMatch(isSearchMatch);
 512         }
 513
 514         public void cancel() {
 515             interrupted = true;
 516         }
 517     }
 518
 519     // ------------------------------------------------------------------------
 520     // Listeners
 521     // ------------------------------------------------------------------------
 522
 523     @Override
 524     public void timeRangeUpdated(TimeGraphRangeUpdateEvent event) {
 525         fStartTime = event.getStartTime();
 526         fStopTime = event.getEndTime();
 527         itemize(fStartTime, fStopTime);
 528         final ITmfTimestamp startTimestamp = TmfTimestamp.fromNanos(event.getStartTime());
 529         final ITmfTimestamp endTimestamp = TmfTimestamp.fromNanos(event.getEndTime());
 530         TmfTimeRange range = new TmfTimeRange(startTimestamp, endTimestamp);
 531         broadcast(new TmfWindowRangeUpdatedSignal(this, range));
 532     }
 533
 534     @Override
 535     public void selectionChanged(TimeGraphSelectionEvent event) {
 536         ITimeGraphEntry timeAnalysisEntry = null;
 537         if (event.getSelection() instanceof TimeChartAnalysisEntry) {
 538             timeAnalysisEntry = event.getSelection();
 539         } else if (event.getSelection() instanceof TimeChartEvent) {
 540             timeAnalysisEntry = ((TimeChartEvent) event.getSelection()).getEntry();
 541         }
 542         if (timeAnalysisEntry instanceof TimeChartAnalysisEntry) {
 543             broadcast(new TmfTraceSelectedSignal(this, ((TimeChartAnalysisEntry) timeAnalysisEntry).getTrace()));
 544         }
 545     }
 546
 547     @Override
 548     public void timeSelected(TimeGraphTimeEvent event) {
 549         broadcast(new TmfSelectionRangeUpdatedSignal(this, TmfTimestamp.fromNanos(event.getBeginTime()), TmfTimestamp.fromNanos(event.getEndTime())));
 550     }
 551
 552     @Override
 553     public void colorSettingsChanged(ColorSetting[] colorSettings) {
 554         // Set presentation provider again to trigger re-creation of new color
 555         // settings which are stored in the TimeGraphControl class
 556         fViewer.setTimeGraphProvider(fPresentationProvider);
 557         redecorate();
 558     }
 559
 560     @Override
 561     public void resourceChanged(IResourceChangeEvent event) {
 562         for (IMarkerDelta delta : event.findMarkerDeltas(IMarker.BOOKMARK, false)) {
 563             for (TimeChartDecorationProvider provider : fDecorationProviders.values()) {
 564                 if (delta.getResource().equals(provider.getBookmarksFile())) {
 565                     if (delta.getKind() == IResourceDelta.REMOVED ||
 566                             delta.getMarker().getAttribute(IMarker.LOCATION, -1) != -1 ||
 567                             delta.getMarker().getAttribute(ITmfMarker.MARKER_RANK, (String) null) != null) {
 568                         provider.refreshBookmarks();
 569                     }
 570                 }
 571             }
 572         }
 573         redecorate();
 574     }
 575
 576     // ------------------------------------------------------------------------
 577     // Signal handlers
 578     // ------------------------------------------------------------------------
 579
 580     /**
 581      * Handler for the Trace Opened signal
 582      *
 583      * @param signal
 584      *            The incoming signal
 585      */
 586     @TmfSignalHandler
 587     public void traceOpened(TmfTraceOpenedSignal signal) {
 588         final ITmfTrace trace = signal.getTrace();
 589         final IFile bookmarksFile = signal.getEditorFile();
 590         TimeChartAnalysisEntry timeAnalysisEntry = null;
 591         for (int i = 0; i < fTimeAnalysisEntries.size(); i++) {
 592             if (fTimeAnalysisEntries.get(i).getTrace().equals(trace)) {
 593                 timeAnalysisEntry = fTimeAnalysisEntries.get(i);
 594                 break;
 595             }
 596         }
 597         if (timeAnalysisEntry == null) {
 598             timeAnalysisEntry = new TimeChartAnalysisEntry(trace, fDisplayWidth * 2);
 599             fTimeAnalysisEntries.add(timeAnalysisEntry);
 600             fDecorationProviders.put(trace, new TimeChartDecorationProvider(bookmarksFile));
 601             Thread thread = new ProcessTraceThread(timeAnalysisEntry);
 602             thread.start();
 603         }
 604         refreshViewer();
 605     }
 606
 607     /**
 608      * Handler for the Trace Closed signal
 609      *
 610      * @param signal
 611      *            The incoming signal
 612      */
 613     @TmfSignalHandler
 614     public void traceClosed(TmfTraceClosedSignal signal) {
 615         final ITmfTrace trace = signal.getTrace();
 616         for (int i = 0; i < fTimeAnalysisEntries.size(); i++) {
 617             if (fTimeAnalysisEntries.get(i).getTrace().equals(trace)) {
 618                 fTimeAnalysisEntries.remove(i);
 619                 fDecorationProviders.remove(trace);
 620                 synchronized (fDecorateThreads) {
 621                     for (DecorateThread thread : fDecorateThreads) {
 622                         if (thread.fTimeAnalysisEntry.getTrace() == trace) {
 623                             thread.cancel();
 624                             fDecorateThreads.remove(thread);
 625                             break;
 626                         }
 627                     }
 628                 }
 629                 refreshViewer();
 630                 break;
 631             }
 632         }
 633     }
 634
 635     /**
 636      * Handler for the Trace Selected signal
 637      *
 638      * @param signal
 639      *            The incoming signal
 640      */
 641     @TmfSignalHandler
 642     public void traceSelected(TmfTraceSelectedSignal signal) {
 643         if (signal.getSource() != this) {
 644             ITmfTrace trace = signal.getTrace();
 645             for (int i = 0; i < fTimeAnalysisEntries.size(); i++) {
 646                 if (fTimeAnalysisEntries.get(i).getTrace().equals(trace)) {
 647                     fViewer.setSelection(fTimeAnalysisEntries.get(i));
 648                     break;
 649                 }
 650             }
 651             TmfTraceContext ctx = TmfTraceManager.getInstance().getCurrentTraceContext();
 652             long beginTime = ctx.getSelectionRange().getStartTime().toNanos();
 653             long endTime = ctx.getSelectionRange().getEndTime().toNanos();
 654             fViewer.setSelectionRange(beginTime, endTime, false);
 655         }
 656     }
 657
 658     /**
 659      * Handler for the Trace Updated signal
 660      *
 661      * @param signal
 662      *            The incoming signal
 663      */
 664     @TmfSignalHandler
 665     public void traceUpdated(TmfTraceUpdatedSignal signal) {
 666         final ITmfTrace trace = signal.getTrace();
 667         for (int i = 0; i < fTimeAnalysisEntries.size(); i++) {
 668             TimeChartAnalysisEntry timeAnalysisEntry = fTimeAnalysisEntries.get(i);
 669             if (timeAnalysisEntry.getTrace().equals(trace)) {
 670                 updateTraceEntry(timeAnalysisEntry, Long.MAX_VALUE, 0, Long.MAX_VALUE);
 671                 break;
 672             }
 673         }
 674     }
 675
 676     /**
 677      * Handler for the selection range updated signal.
 678      *
 679      * @param signal
 680      *            The incoming signal
 681      * @since 1.0
 682      */
 683     @TmfSignalHandler
 684     public void selectionRangeUpdated(TmfSelectionRangeUpdatedSignal signal) {
 685         final long beginTime = signal.getBeginTime().toNanos();
 686         final long endTime = signal.getEndTime().toNanos();
 687
 688         Display.getDefault().asyncExec(new Runnable() {
 689             @Override
 690             public void run() {
 691                 if (beginTime == endTime) {
 692                     fViewer.setSelectedTime(beginTime, true);
 693                     if (fStartTime != fViewer.getTime0() || fStopTime != fViewer.getTime1()) {
 694                         fStartTime = fViewer.getTime0();
 695                         fStopTime = fViewer.getTime1();
 696                         itemize(fStartTime, fStopTime);
 697                     }
 698                 } else {
 699                     fViewer.setSelectionRange(beginTime, endTime, true);
 700                 }
 701             }
 702         });
 703     }
 704
 705     /**
 706      * Handler for the window range updated signal.
 707      *
 708      * @param signal
 709      *            The incoming signal
 710      * @since 1.0
 711      */
 712     @TmfSignalHandler
 713     public void windowRangeUpdated(final TmfWindowRangeUpdatedSignal signal) {
 714         if (signal.getSource() == this) {
 715             return;
 716         }
 717         final long startTime = signal.getCurrentRange().getStartTime().toNanos();
 718         final long endTime = signal.getCurrentRange().getEndTime().toNanos();
 719         Display.getDefault().asyncExec(new Runnable() {
 720             @Override
 721             public void run() {
 722                 fStartTime = startTime;
 723                 fStopTime = endTime;
 724                 itemize(fStartTime, fStopTime);
 725                 fViewer.setStartFinishTime(startTime, endTime);
 726             }
 727         });
 728     }
 729
 730     /**
 731      * Handler for the Event Filter Applied signal
 732      *
 733      * @param signal
 734      *            The incoming signal
 735      */
 736     @TmfSignalHandler
 737     public void filterApplied(TmfEventFilterAppliedSignal signal) {
 738         TimeChartDecorationProvider decorationProvider = fDecorationProviders.get(signal.getTrace());
 739         if (decorationProvider == null) {
 740             return;
 741         }
 742         decorationProvider.filterApplied(signal.getEventFilter());
 743         redecorate();
 744     }
 745
 746     /**
 747      * Handler for the Event Search Applied signal
 748      *
 749      * @param signal
 750      *            The incoming signal
 751      */
 752     @TmfSignalHandler
 753     public void searchApplied(TmfEventSearchAppliedSignal signal) {
 754         TimeChartDecorationProvider decorationProvider = fDecorationProviders.get(signal.getTrace());
 755         if (decorationProvider == null) {
 756             return;
 757         }
 758         decorationProvider.searchApplied(signal.getSearchFilter());
 759         redecorate();
 760     }
 761
 762     /**
 763      * @since 1.0
 764      */
 765     @Override
 766     public TmfTimeViewAlignmentInfo getTimeViewAlignmentInfo() {
 767         if (fViewer == null) {
 768             return null;
 769         }
 770         return fViewer.getTimeViewAlignmentInfo();
 771     }
 772
 773     /**
 774      * @since 1.0
 775      */
 776     @Override
 777     public int getAvailableWidth(int requestedOffset) {
 778         return fViewer.getAvailableWidth(requestedOffset);
 779     }
 780
 781     /**
 782      * @since 1.0
 783      */
 784     @Override
 785     public void performAlign(int offset, int width) {
 786         fViewer.performAlign(offset, width);
 787     }
 788 }