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