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

   1 /*******************************************************************************
   2  * Copyright (c) 2010 Ericsson
   3  *
   4  * All rights reserved. This program and the accompanying materials are
   5  * made available under the terms of the Eclipse Public License v1.0 which
   6  * accompanies this distribution, and is available at
   7  * http://www.eclipse.org/legal/epl-v10.html
   8  *
   9  * Contributors:
  10  *   Patrick Tasse - Initial API and implementation
  11  *******************************************************************************/
  12
  13 package org.eclipse.linuxtools.tmf.ui.views.timechart;
  14
  15 import java.util.ArrayList;
  16 import java.util.HashMap;
  17 import java.util.Iterator;
  18 import java.util.Map;
  19
  20 import org.eclipse.core.resources.IFile;
  21 import org.eclipse.core.resources.IMarker;
  22 import org.eclipse.core.resources.IMarkerDelta;
  23 import org.eclipse.core.resources.IResourceChangeEvent;
  24 import org.eclipse.core.resources.IResourceChangeListener;
  25 import org.eclipse.core.resources.IResourceDelta;
  26 import org.eclipse.core.resources.ResourcesPlugin;
  27 import org.eclipse.linuxtools.tmf.core.event.ITmfEvent;
  28 import org.eclipse.linuxtools.tmf.core.event.TmfTimestamp;
  29 import org.eclipse.linuxtools.tmf.core.filter.ITmfFilter;
  30 import org.eclipse.linuxtools.tmf.core.signal.TmfSignalHandler;
  31 import org.eclipse.linuxtools.tmf.core.signal.TmfTimeSynchSignal;
  32 import org.eclipse.linuxtools.tmf.core.signal.TmfTraceSelectedSignal;
  33 import org.eclipse.linuxtools.tmf.core.signal.TmfTraceUpdatedSignal;
  34 import org.eclipse.linuxtools.tmf.core.trace.ITmfContext;
  35 import org.eclipse.linuxtools.tmf.core.trace.ITmfTrace;
  36 import org.eclipse.linuxtools.tmf.ui.editors.ITmfTraceEditor;
  37 import org.eclipse.linuxtools.tmf.ui.signal.TmfTraceClosedSignal;
  38 import org.eclipse.linuxtools.tmf.ui.signal.TmfTraceOpenedSignal;
  39 import org.eclipse.linuxtools.tmf.ui.viewers.events.ITmfEventsFilterListener;
  40 import org.eclipse.linuxtools.tmf.ui.viewers.events.ITmfEventsFilterProvider;
  41 import org.eclipse.linuxtools.tmf.ui.views.TmfView;
  42 import org.eclipse.linuxtools.tmf.ui.views.colors.ColorSetting;
  43 import org.eclipse.linuxtools.tmf.ui.views.colors.ColorSettingsManager;
  44 import org.eclipse.linuxtools.tmf.ui.views.colors.IColorSettingsListener;
  45 import org.eclipse.linuxtools.tmf.ui.views.timechart.TimeChartEvent.RankRange;
  46 import org.eclipse.linuxtools.tmf.ui.widgets.timegraph.ITimeGraphPresentationProvider;
  47 import org.eclipse.linuxtools.tmf.ui.widgets.timegraph.ITimeGraphRangeListener;
  48 import org.eclipse.linuxtools.tmf.ui.widgets.timegraph.ITimeGraphSelectionListener;
  49 import org.eclipse.linuxtools.tmf.ui.widgets.timegraph.ITimeGraphTimeListener;
  50 import org.eclipse.linuxtools.tmf.ui.widgets.timegraph.TimeGraphRangeUpdateEvent;
  51 import org.eclipse.linuxtools.tmf.ui.widgets.timegraph.TimeGraphSelectionEvent;
  52 import org.eclipse.linuxtools.tmf.ui.widgets.timegraph.TimeGraphTimeEvent;
  53 import org.eclipse.linuxtools.tmf.ui.widgets.timegraph.TimeGraphViewer;
  54 import org.eclipse.linuxtools.tmf.ui.widgets.timegraph.model.ITimeEvent;
  55 import org.eclipse.linuxtools.tmf.ui.widgets.timegraph.model.ITimeGraphEntry;
  56 import org.eclipse.swt.SWT;
  57 import org.eclipse.swt.widgets.Composite;
  58 import org.eclipse.swt.widgets.Display;
  59 import org.eclipse.ui.IEditorPart;
  60 import org.eclipse.ui.IEditorReference;
  61
  62 /**
  63  * Generic Time Chart view, which is similar to a Gantt chart for trace analysis
  64  *
  65  * @version 1.0
  66  * @author Patrick Tasse
  67  */
  68 public class TimeChartView extends TmfView implements ITimeGraphRangeListener, ITimeGraphSelectionListener, ITimeGraphTimeListener, IColorSettingsListener,
  69         IResourceChangeListener, ITmfEventsFilterListener {
  70
  71     public static final String ID = "org.eclipse.linuxtools.tmf.ui.views.timechart"; //$NON-NLS-1$
  72
  73     private static final int TIMESTAMP_SCALE = -9;
  74
  75     private final int fDisplayWidth;
  76     private TimeGraphViewer fViewer;
  77     private final ArrayList<TimeChartAnalysisEntry> fTimeAnalysisEntries = new ArrayList<TimeChartAnalysisEntry>();
  78     private final Map<ITmfTrace<?>, TimeChartDecorationProvider> fDecorationProviders = new HashMap<ITmfTrace<?>, TimeChartDecorationProvider>();
  79     private ArrayList<DecorateThread> fDecorateThreads;
  80     private long fStartTime = 0;
  81     private long fStopTime = Long.MAX_VALUE;
  82     private boolean fRefreshBusy = false;
  83     private boolean fRefreshPending = false;
  84     private boolean fRedrawBusy = false;
  85     private boolean fRedrawPending = false;
  86     private final Object fSyncObj = new Object();
  87     private ITimeGraphPresentationProvider fPresentationProvider;
  88
  89     public TimeChartView() {
  90         super("Time Chart"); //$NON-NLS-1$
  91         fDisplayWidth = Display.getDefault().getBounds().width;
  92     }
  93
  94     @Override
  95     public void createPartControl(Composite parent) {
  96         fViewer = new TimeGraphViewer(parent, SWT.NONE);
  97         fPresentationProvider = new TimeChartAnalysisProvider();
  98         fViewer.setTimeGraphProvider(fPresentationProvider);
  99         fViewer.setTimeCalendarFormat(true);
 100         fViewer.addTimeListener(this);
 101         fViewer.addRangeListener(this);
 102         fViewer.addSelectionListener(this);
 103         fViewer.setMinimumItemWidth(1);
 104
 105         IEditorReference[] editorReferences = getSite().getPage().getEditorReferences();
 106         for (IEditorReference editorReference : editorReferences) {
 107             IEditorPart editor = editorReference.getEditor(false);
 108             if (editor instanceof ITmfTraceEditor) {
 109                 ITmfTrace<?> trace = ((ITmfTraceEditor) editor).getTrace();
 110                 if (trace != null) {
 111                     IFile bookmarksFile = ((ITmfTraceEditor) editor).getBookmarksFile();
 112                     TimeChartAnalysisEntry timeAnalysisEntry = new TimeChartAnalysisEntry(trace, fDisplayWidth * 2);
 113                     fTimeAnalysisEntries.add(timeAnalysisEntry);
 114                     fDecorationProviders.put(trace, new TimeChartDecorationProvider(bookmarksFile));
 115                     Thread thread = new ProcessTraceThread(timeAnalysisEntry);
 116                     thread.start();
 117                 }
 118             }
 119         }
 120         fViewer.setInput(fTimeAnalysisEntries.toArray(new TimeChartAnalysisEntry[0]));
 121
 122         fDecorateThreads = new ArrayList<DecorateThread>();
 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             } else {
 224                 fRefreshBusy = true;
 225             }
 226         }
 227         // Perform the refresh on the UI thread
 228         Display.getDefault().asyncExec(new Runnable() {
 229             @Override
 230             public void run() {
 231                 if (fViewer.getControl().isDisposed()) {
 232                     return;
 233                 }
 234                 fViewer.setInput(fTimeAnalysisEntries.toArray(new TimeChartAnalysisEntry[0]));
 235                 fViewer.resetStartFinishTime();
 236                 synchronized (fSyncObj) {
 237                     fRefreshBusy = false;
 238                     if (fRefreshPending) {
 239                         fRefreshPending = false;
 240                         refreshViewer();
 241                     }
 242                 }
 243             }
 244         });
 245     }
 246
 247     private void redrawViewer(boolean resetTimeIntervals) {
 248         synchronized (fSyncObj) {
 249             if (fRedrawBusy) {
 250                 fRedrawPending = true;
 251                 return;
 252             } else {
 253                 fRedrawBusy = true;
 254             }
 255         }
 256         final boolean reset = resetTimeIntervals;
 257         // Perform the refresh on the UI thread
 258         Display.getDefault().asyncExec(new Runnable() {
 259             @Override
 260             public void run() {
 261                 if (fViewer.getControl().isDisposed()) {
 262                     return;
 263                 }
 264                 if (reset) {
 265                     fViewer.setTimeRange(fTimeAnalysisEntries.toArray(new TimeChartAnalysisEntry[0]));
 266                     fViewer.setTimeBounds();
 267                 }
 268                 fViewer.getControl().redraw();
 269                 fViewer.getControl().update();
 270                 synchronized (fSyncObj) {
 271                     fRedrawBusy = false;
 272                     if (fRedrawPending) {
 273                         fRedrawPending = false;
 274                         redrawViewer(reset);
 275                     }
 276                 }
 277             }
 278         });
 279     }
 280
 281     private void itemize(long startTime, long stopTime) {
 282         for (int i = 0; i < fTimeAnalysisEntries.size(); i++) {
 283             Thread thread = new ItemizeThread(fTimeAnalysisEntries.get(i), startTime, stopTime);
 284             thread.start();
 285         }
 286     }
 287
 288     private class ItemizeThread extends Thread {
 289
 290         private final TimeChartAnalysisEntry fTimeAnalysisEntry;
 291         private final long fStartTime;
 292         private final long fStopTime;
 293         private final long fMaxDuration;
 294
 295         private ItemizeThread(TimeChartAnalysisEntry timeAnalysisEntry, long startTime, long stopTime) {
 296             super("Itemize Thread:" + timeAnalysisEntry.getName()); //$NON-NLS-1$
 297             fTimeAnalysisEntry = timeAnalysisEntry;
 298             fStartTime = startTime;
 299             fStopTime = stopTime;
 300             fMaxDuration = 3 * (fStopTime - fStartTime) / fDisplayWidth;
 301         }
 302
 303         @Override
 304         public void run() {
 305             itemizeTraceEntry(fTimeAnalysisEntry);
 306         }
 307
 308         public void itemizeTraceEntry(TimeChartAnalysisEntry timeAnalysisEntry) {
 309             Iterator<ITimeEvent> iterator = timeAnalysisEntry.getTimeEventsIterator();
 310             TimeChartEvent event = null;
 311             boolean hasNext = true;
 312             while (hasNext) {
 313                 synchronized (timeAnalysisEntry) {
 314                     while (hasNext = iterator.hasNext()) {
 315                         event = (TimeChartEvent) iterator.next();
 316                         if (event.getTime() + event.getDuration() > fStartTime && event.getTime() < fStopTime && event.getDuration() > fMaxDuration
 317                                 && event.getNbEvents() > 1) {
 318                             break;
 319                         }
 320                     }
 321                 }
 322                 if (hasNext) {
 323                     if (event.getItemizedEntry() == null) {
 324                         itemizeEvent(event);
 325                     } else {
 326                         itemizeTraceEntry(event.getItemizedEntry());
 327                     }
 328                 }
 329             }
 330         }
 331
 332         public void itemizeEvent(TimeChartEvent event) {
 333             synchronized (event) {
 334                 if (event.isItemizing()) {
 335                     return;
 336                 }
 337                 event.setItemizing(true);
 338             }
 339             TimeChartAnalysisEntry timeAnalysisEntry = new TimeChartAnalysisEntry(fTimeAnalysisEntry.getTrace(), (int) Math.min(
 340                     event.getNbEvents() + 1, fDisplayWidth * 2));
 341             synchronized (event.getRankRangeList()) {
 342                 for (RankRange range : event.getRankRangeList()) {
 343                     timeAnalysisEntry.setLastRank(range.getFirstRank());
 344                     updateTraceEntry(timeAnalysisEntry, range.getLastRank() + 1, event.getTime(), event.getTime() + event.getDuration());
 345                 }
 346             }
 347             event.setItemizedEntry(timeAnalysisEntry);
 348             redrawViewer(false);
 349             itemizeTraceEntry(timeAnalysisEntry);
 350             synchronized (event) {
 351                 event.setItemizing(false);
 352             }
 353         }
 354     }
 355
 356     private void redecorate() {
 357         synchronized (fDecorateThreads) {
 358             for (DecorateThread thread : fDecorateThreads) {
 359                 thread.cancel();
 360             }
 361             fDecorateThreads.clear();
 362             for (int i = 0; i < fTimeAnalysisEntries.size(); i++) {
 363                 DecorateThread thread = new DecorateThread(fTimeAnalysisEntries.get(i));
 364                 thread.start();
 365                 fDecorateThreads.add(thread);
 366             }
 367         }
 368     }
 369
 370     private class DecorateThread extends Thread {
 371         private volatile boolean interrupted = false;
 372         private final TimeChartAnalysisEntry fTimeAnalysisEntry;
 373         private final TimeChartDecorationProvider fDecorationProvider;
 374         private ITmfContext fContext;
 375         private int fCount = 0;
 376
 377         private DecorateThread(TimeChartAnalysisEntry timeAnalysisEntry) {
 378             super("Decorate Thread:" + timeAnalysisEntry.getName()); //$NON-NLS-1$
 379             fTimeAnalysisEntry = timeAnalysisEntry;
 380             fDecorationProvider = fDecorationProviders.get(timeAnalysisEntry.getTrace());
 381         }
 382
 383         @Override
 384         public void run() {
 385             resetTraceEntry(fTimeAnalysisEntry);
 386             redrawViewer(false);
 387             decorateTraceEntry(fTimeAnalysisEntry, null);
 388             redrawViewer(false);
 389             synchronized (fDecorateThreads) {
 390                 fDecorateThreads.remove(this);
 391             }
 392             if (fContext != null) {
 393                 fContext.dispose();
 394             }
 395         }
 396
 397         public void resetTraceEntry(TimeChartAnalysisEntry timeAnalysisEntry) {
 398             Iterator<ITimeEvent> iterator = timeAnalysisEntry.getTimeEventsIterator();
 399             TimeChartEvent event = null;
 400             boolean hasNext = true;
 401             while (!interrupted && hasNext) {
 402                 synchronized (timeAnalysisEntry) {
 403                     while (hasNext = iterator.hasNext()) {
 404                         event = (TimeChartEvent) iterator.next();
 405                         break;
 406                     }
 407                 }
 408                 if (hasNext) {
 409                     // TODO possible concurrency problem here with ItemizeJob
 410                     event.setColorSettingPriority(ColorSettingsManager.PRIORITY_NONE);
 411                     if (event.getItemizedEntry() != null) {
 412                         resetTraceEntry(event.getItemizedEntry());
 413                     }
 414                 }
 415             }
 416         }
 417
 418         public void decorateTraceEntry(TimeChartAnalysisEntry timeAnalysisEntry, TimeChartEvent parentEvent) {
 419             // Set max duration high to ensure iterator does not consider
 420             // itemized events
 421             Iterator<ITimeEvent> iterator = timeAnalysisEntry.getTimeEventsIterator(0, Long.MAX_VALUE, Long.MAX_VALUE);
 422             TimeChartEvent event = null;
 423             int entryPriority = ColorSettingsManager.PRIORITY_NONE;
 424             boolean entryIsBookmarked = false;
 425             boolean entryIsVisible = false;
 426             boolean entryIsSearchMatch = false;
 427             boolean hasNext = true;
 428             while (!interrupted && hasNext) {
 429                 synchronized (timeAnalysisEntry) {
 430                     while (hasNext = iterator.hasNext()) {
 431                         event = (TimeChartEvent) iterator.next();
 432                         break;
 433                     }
 434                 }
 435                 if (hasNext) {
 436                     // TODO possible concurrency problem here with ItemizeJob
 437                     if (event.getItemizedEntry() == null) {
 438                         decorateEvent(event);
 439                     } else {
 440                         decorateTraceEntry(event.getItemizedEntry(), event);
 441                     }
 442                     entryPriority = Math.min(entryPriority, event.getColorSettingPriority());
 443                     entryIsBookmarked |= event.isBookmarked();
 444                     entryIsVisible |= event.isVisible();
 445                     entryIsSearchMatch |= event.isSearchMatch();
 446                     if (++fCount % timeAnalysisEntry.getTrace().getCacheSize() == 0) {
 447                         redrawViewer(false);
 448                     }
 449                 }
 450             }
 451             if (parentEvent != null) {
 452                 parentEvent.setColorSettingPriority(entryPriority);
 453                 parentEvent.setIsBookmarked(entryIsBookmarked);
 454                 parentEvent.setIsVisible(entryIsVisible);
 455                 parentEvent.setIsSearchMatch(entryIsSearchMatch);
 456             }
 457         }
 458
 459         public void decorateEvent(TimeChartEvent timeChartEvent) {
 460             // TODO possible concurrency problem here with ItemizeJob
 461             TimeChartAnalysisEntry timeAnalysisEntry = (TimeChartAnalysisEntry) timeChartEvent.getEntry();
 462             ITmfTrace<?> trace = timeAnalysisEntry.getTrace();
 463             int priority = ColorSettingsManager.PRIORITY_NONE;
 464             boolean isBookmarked = false;
 465             boolean isVisible = false;
 466             boolean isSearchMatch = false;
 467             synchronized (timeChartEvent.getRankRangeList()) {
 468                 for (RankRange range : timeChartEvent.getRankRangeList()) {
 469                     if (interrupted) {
 470                         return;
 471                     }
 472                     if (fContext == null || fContext.getRank() != range.getFirstRank()) {
 473                         if (fContext != null) {
 474                                 fContext.dispose();
 475                         }
 476                         fContext = trace.seekEvent(range.getFirstRank());
 477                         fContext.setRank(range.getFirstRank());
 478                     }
 479                     while (true) {
 480                         if (interrupted) {
 481                             return;
 482                         }
 483                         long rank = fContext.getRank();
 484                         ITmfEvent event = trace.getNext(fContext);
 485                         if (event == null) {
 486                             break;
 487                         }
 488                         long eventTime = event.getTimestamp().normalize(0, -9).getValue();
 489                         if (eventTime >= timeChartEvent.getTime() && eventTime <= timeChartEvent.getTime() + timeChartEvent.getDuration()) {
 490                             priority = Math.min(priority, ColorSettingsManager.getColorSettingPriority(event));
 491                         }
 492                         isBookmarked |= fDecorationProvider.isBookmark(rank);
 493                         isVisible |= fDecorationProvider.isVisible(event);
 494                         isSearchMatch |= fDecorationProvider.isSearchMatch(event);
 495                         if (fContext.getRank() > range.getLastRank()) {
 496                             break;
 497                         }
 498                     }
 499                 }
 500             }
 501             timeChartEvent.setColorSettingPriority(priority);
 502             timeChartEvent.setIsBookmarked(isBookmarked);
 503             timeChartEvent.setIsVisible(isVisible);
 504             timeChartEvent.setIsSearchMatch(isSearchMatch);
 505         }
 506
 507         public void cancel() {
 508             interrupted = true;
 509         }
 510     }
 511
 512     // ------------------------------------------------------------------------
 513     // Listeners
 514     // ------------------------------------------------------------------------
 515
 516     @Override
 517     public void timeRangeUpdated(TimeGraphRangeUpdateEvent event) {
 518         fStartTime = event.getStartTime();
 519         fStopTime = event.getEndTime();
 520         itemize(fStartTime, fStopTime);
 521     }
 522
 523     @Override
 524     public void selectionChanged(TimeGraphSelectionEvent event) {
 525         ITimeGraphEntry timeAnalysisEntry = null;
 526         if (event.getSelection() instanceof TimeChartAnalysisEntry) {
 527             timeAnalysisEntry = event.getSelection();
 528         } else if (event.getSelection() instanceof TimeChartEvent) {
 529             timeAnalysisEntry = ((TimeChartEvent) event.getSelection()).getEntry();
 530         }
 531         if (timeAnalysisEntry instanceof TimeChartAnalysisEntry) {
 532             broadcast(new TmfTraceSelectedSignal(this, ((TimeChartAnalysisEntry) timeAnalysisEntry).getTrace()));
 533         }
 534     }
 535
 536     @Override
 537     public void timeSelected(TimeGraphTimeEvent event) {
 538         broadcast(new TmfTimeSynchSignal(this, new TmfTimestamp(event.getTime(), TIMESTAMP_SCALE)));
 539     }
 540
 541     @Override
 542     public void colorSettingsChanged(ColorSetting[] colorSettings) {
 543         // Set presentation provider again to trigger re-creation of new color settings which are stored
 544         // in the TimeGraphControl class
 545         fViewer.setTimeGraphProvider(fPresentationProvider);
 546         redecorate();
 547     }
 548
 549     @Override
 550     public void resourceChanged(IResourceChangeEvent event) {
 551         for (IMarkerDelta delta : event.findMarkerDeltas(IMarker.BOOKMARK, false)) {
 552             for (TimeChartDecorationProvider provider : fDecorationProviders.values()) {
 553                 if (delta.getResource().equals(provider.getBookmarksFile())) {
 554                     if (delta.getKind() == IResourceDelta.CHANGED && delta.getMarker().getAttribute(IMarker.LOCATION, -1) != -1) {
 555                         provider.refreshBookmarks();
 556                     } else if (delta.getKind() == IResourceDelta.REMOVED) {
 557                         provider.refreshBookmarks();
 558                     }
 559                 }
 560             }
 561         }
 562         redecorate();
 563     }
 564
 565     @Override
 566     public void filterApplied(ITmfFilter filter, ITmfTrace<?> trace) {
 567         TimeChartDecorationProvider decorationProvider = fDecorationProviders.get(trace);
 568         decorationProvider.filterApplied(filter);
 569         redecorate();
 570     }
 571
 572     @Override
 573     public void searchApplied(ITmfFilter filter, ITmfTrace<?> trace) {
 574         TimeChartDecorationProvider decorationProvider = fDecorationProviders.get(trace);
 575         decorationProvider.searchApplied(filter);
 576         redecorate();
 577     }
 578
 579     // ------------------------------------------------------------------------
 580     // Signal handlers
 581     // ------------------------------------------------------------------------
 582
 583     @TmfSignalHandler
 584     public void traceOpened(TmfTraceOpenedSignal signal) {
 585         if (fTimeAnalysisEntries == null) {
 586             return;
 587         }
 588         final ITmfTrace<?> trace = signal.getTrace();
 589         final IFile bookmarksFile = signal.getBookmarksFile();
 590         final ITmfEventsFilterProvider eventsFilterProvider = signal.getEventsFilterProvider();
 591         TimeChartAnalysisEntry timeAnalysisEntry = null;
 592         for (int i = 0; i < fTimeAnalysisEntries.size(); i++) {
 593             if (fTimeAnalysisEntries.get(i).getTrace().equals(trace)) {
 594                 timeAnalysisEntry = fTimeAnalysisEntries.get(i);
 595                 break;
 596             }
 597         }
 598         if (timeAnalysisEntry == null) {
 599             timeAnalysisEntry = new TimeChartAnalysisEntry(trace, fDisplayWidth * 2);
 600             fTimeAnalysisEntries.add(timeAnalysisEntry);
 601             fDecorationProviders.put(trace, new TimeChartDecorationProvider(bookmarksFile));
 602             Thread thread = new ProcessTraceThread(timeAnalysisEntry);
 603             thread.start();
 604         }
 605         refreshViewer();
 606         if (eventsFilterProvider != null) {
 607             eventsFilterProvider.addEventsFilterListener(this);
 608         }
 609     }
 610
 611     @TmfSignalHandler
 612     public void traceClosed(TmfTraceClosedSignal signal) {
 613         if (fTimeAnalysisEntries == null) {
 614             return;
 615         }
 616         final ITmfTrace<?> trace = signal.getTrace();
 617         for (int i = 0; i < fTimeAnalysisEntries.size(); i++) {
 618             if (fTimeAnalysisEntries.get(i).getTrace().equals(trace)) {
 619                 fTimeAnalysisEntries.remove(i);
 620                 fDecorationProviders.remove(trace);
 621                 refreshViewer();
 622                 break;
 623             }
 624         }
 625     }
 626
 627     @TmfSignalHandler
 628     public void traceSelected(TmfTraceSelectedSignal signal) {
 629         if (signal.getSource() != this && fTimeAnalysisEntries != null) {
 630             ITmfTrace<?> trace = signal.getTrace();
 631             for (int i = 0; i < fTimeAnalysisEntries.size(); i++) {
 632                 if (fTimeAnalysisEntries.get(i).getTrace().equals(trace)) {
 633                     fViewer.setSelection(fTimeAnalysisEntries.get(i));
 634                     break;
 635                 }
 636             }
 637         }
 638     }
 639
 640     @TmfSignalHandler
 641     public void traceUpdated(TmfTraceUpdatedSignal signal) {
 642         if (fTimeAnalysisEntries == null) {
 643             return;
 644         }
 645         final ITmfTrace<?> trace = signal.getTrace();
 646         for (int i = 0; i < fTimeAnalysisEntries.size(); i++) {
 647             TimeChartAnalysisEntry timeAnalysisEntry = fTimeAnalysisEntries.get(i);
 648             if (timeAnalysisEntry.getTrace().equals(trace)) {
 649                 updateTraceEntry(timeAnalysisEntry, Long.MAX_VALUE, 0, Long.MAX_VALUE);
 650                 break;
 651             }
 652         }
 653     }
 654
 655     @TmfSignalHandler
 656     public void currentTimeUpdated(TmfTimeSynchSignal signal) {
 657         final long time = signal.getCurrentTime().normalize(0, TIMESTAMP_SCALE).getValue();
 658         Display.getDefault().asyncExec(new Runnable() {
 659             @Override
 660             public void run() {
 661                 fViewer.setSelectedTime(time, true);
 662             }
 663         });
 664     }
 665
 666 }