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

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