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