1 /*******************************************************************************
2 * Copyright (c) 2010, 2014 Ericsson
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
10 * Patrick Tasse - Initial API and implementation
11 *******************************************************************************/
13 package org
.eclipse
.tracecompass
.tmf
.ui
.views
.timechart
;
15 import java
.util
.ArrayList
;
16 import java
.util
.HashMap
;
17 import java
.util
.Iterator
;
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
.TmfRangeSynchSignal
;
35 import org
.eclipse
.tracecompass
.tmf
.core
.signal
.TmfSignalHandler
;
36 import org
.eclipse
.tracecompass
.tmf
.core
.signal
.TmfTimeSynchSignal
;
37 import org
.eclipse
.tracecompass
.tmf
.core
.signal
.TmfTraceClosedSignal
;
38 import org
.eclipse
.tracecompass
.tmf
.core
.signal
.TmfTraceOpenedSignal
;
39 import org
.eclipse
.tracecompass
.tmf
.core
.signal
.TmfTraceSelectedSignal
;
40 import org
.eclipse
.tracecompass
.tmf
.core
.signal
.TmfTraceUpdatedSignal
;
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
.views
.TmfView
;
49 import org
.eclipse
.tracecompass
.tmf
.ui
.views
.colors
.ColorSetting
;
50 import org
.eclipse
.tracecompass
.tmf
.ui
.views
.colors
.ColorSettingsManager
;
51 import org
.eclipse
.tracecompass
.tmf
.ui
.views
.colors
.IColorSettingsListener
;
52 import org
.eclipse
.tracecompass
.tmf
.ui
.views
.timechart
.TimeChartEvent
.RankRange
;
53 import org
.eclipse
.tracecompass
.tmf
.ui
.widgets
.timegraph
.ITimeGraphPresentationProvider
;
54 import org
.eclipse
.tracecompass
.tmf
.ui
.widgets
.timegraph
.ITimeGraphRangeListener
;
55 import org
.eclipse
.tracecompass
.tmf
.ui
.widgets
.timegraph
.ITimeGraphSelectionListener
;
56 import org
.eclipse
.tracecompass
.tmf
.ui
.widgets
.timegraph
.ITimeGraphTimeListener
;
57 import org
.eclipse
.tracecompass
.tmf
.ui
.widgets
.timegraph
.TimeGraphRangeUpdateEvent
;
58 import org
.eclipse
.tracecompass
.tmf
.ui
.widgets
.timegraph
.TimeGraphSelectionEvent
;
59 import org
.eclipse
.tracecompass
.tmf
.ui
.widgets
.timegraph
.TimeGraphTimeEvent
;
60 import org
.eclipse
.tracecompass
.tmf
.ui
.widgets
.timegraph
.TimeGraphViewer
;
61 import org
.eclipse
.tracecompass
.tmf
.ui
.widgets
.timegraph
.model
.ITimeEvent
;
62 import org
.eclipse
.tracecompass
.tmf
.ui
.widgets
.timegraph
.model
.ITimeGraphEntry
;
63 import org
.eclipse
.tracecompass
.tmf
.ui
.widgets
.timegraph
.widgets
.Utils
.TimeFormat
;
66 * Generic Time Chart view, which is similar to a Gantt chart for trace analysis
69 * @author Patrick Tasse
71 public class TimeChartView
extends TmfView
implements ITimeGraphRangeListener
, ITimeGraphSelectionListener
, ITimeGraphTimeListener
, IColorSettingsListener
, IResourceChangeListener
{
73 /** TimeChartView's ID */
74 public static final String ID
= "org.eclipse.linuxtools.tmf.ui.views.timechart"; //$NON-NLS-1$
76 private static final int TIMESTAMP_SCALE
= -9;
78 private final int fDisplayWidth
;
79 private TimeGraphViewer fViewer
;
80 private final ArrayList
<TimeChartAnalysisEntry
> fTimeAnalysisEntries
= new ArrayList
<>();
81 private final Map
<ITmfTrace
, TimeChartDecorationProvider
> fDecorationProviders
= new HashMap
<>();
82 private final ArrayList
<DecorateThread
> fDecorateThreads
= new ArrayList
<>();
83 private long fStartTime
= 0;
84 private long fStopTime
= Long
.MAX_VALUE
;
85 private boolean fRefreshBusy
= false;
86 private boolean fRefreshPending
= false;
87 private boolean fRedrawBusy
= false;
88 private boolean fRedrawPending
= false;
89 private final Object fSyncObj
= new Object();
90 private ITimeGraphPresentationProvider fPresentationProvider
;
95 public TimeChartView() {
96 super("Time Chart"); //$NON-NLS-1$
97 fDisplayWidth
= Display
.getDefault().getBounds().width
;
101 public void createPartControl(Composite parent
) {
102 fViewer
= new TimeGraphViewer(parent
, SWT
.NONE
);
103 fPresentationProvider
= new TimeChartAnalysisProvider();
104 fViewer
.setTimeGraphProvider(fPresentationProvider
);
105 fViewer
.setTimeFormat(TimeFormat
.CALENDAR
);
106 fViewer
.addTimeListener(this);
107 fViewer
.addRangeListener(this);
108 fViewer
.addSelectionListener(this);
109 fViewer
.setMinimumItemWidth(1);
111 IStatusLineManager statusLineManager
= getViewSite().getActionBars().getStatusLineManager();
112 fViewer
.getTimeGraphControl().setStatusLineManager(statusLineManager
);
114 for (ITmfTrace trace
: TmfTraceManager
.getInstance().getOpenedTraces()) {
115 IFile bookmarksFile
= TmfTraceManager
.getInstance().getTraceEditorFile(trace
);
116 TimeChartAnalysisEntry timeAnalysisEntry
= new TimeChartAnalysisEntry(trace
, fDisplayWidth
* 2);
117 fTimeAnalysisEntries
.add(timeAnalysisEntry
);
118 fDecorationProviders
.put(trace
, new TimeChartDecorationProvider(bookmarksFile
));
119 Thread thread
= new ProcessTraceThread(timeAnalysisEntry
);
122 fViewer
.setInput(fTimeAnalysisEntries
.toArray(new TimeChartAnalysisEntry
[0]));
124 ColorSettingsManager
.addColorSettingsListener(this);
125 ResourcesPlugin
.getWorkspace().addResourceChangeListener(this, IResourceChangeEvent
.POST_CHANGE
);
129 public void dispose() {
130 ResourcesPlugin
.getWorkspace().removeResourceChangeListener(this);
131 for (DecorateThread thread
: fDecorateThreads
) {
134 ColorSettingsManager
.removeColorSettingsListener(this);
139 public void setFocus() {
143 private class ProcessTraceThread
extends Thread
{
145 private final TimeChartAnalysisEntry fTimeAnalysisEntry
;
147 public ProcessTraceThread(TimeChartAnalysisEntry timeAnalysisEntry
) {
148 super("ProcessTraceJob:" + timeAnalysisEntry
.getName()); //$NON-NLS-1$
149 fTimeAnalysisEntry
= timeAnalysisEntry
;
154 updateTraceEntry(fTimeAnalysisEntry
, Long
.MAX_VALUE
, 0, Long
.MAX_VALUE
);
158 private void updateTraceEntry(TimeChartAnalysisEntry timeAnalysisEntry
, long stopRank
, long startTime
, long stopTime
) {
159 ITmfTrace trace
= timeAnalysisEntry
.getTrace();
160 TimeChartDecorationProvider decorationProvider
= fDecorationProviders
.get(trace
);
161 if (decorationProvider
== null) {
162 return; // the trace has been closed
164 ITmfContext context
= null;
165 // TmfTimestamp lastTimestamp = null;
166 boolean done
= false;
168 synchronized (timeAnalysisEntry
) {
169 if (timeAnalysisEntry
.getLastRank() >= trace
.getNbEvents()) {
173 if (context
== null || context
.getRank() != timeAnalysisEntry
.getLastRank()) {
174 if (context
!= null) {
177 if (timeAnalysisEntry
.getLastRank() != -1) {
178 context
= trace
.seekEvent(timeAnalysisEntry
.getLastRank());
180 // context = trace.seekLocation(null);
181 context
= trace
.seekEvent(0);
185 long rank
= context
.getRank();
186 ITmfEvent event
= trace
.getNext(context
);
191 // if (!event.getTimestamp().equals(lastTimestamp)) {
192 TimeChartEvent timeEvent
= new TimeChartEvent(timeAnalysisEntry
, event
, rank
, decorationProvider
);
193 if (timeEvent
.getTime() >= startTime
&& timeEvent
.getTime() <= stopTime
) {
194 timeAnalysisEntry
.addTraceEvent(timeEvent
);
196 // lastTimestamp = event.getTimestamp();
197 // } *** commented out so that color setting priority gets
198 // set even if the event has same time
199 if (context
.getRank() == trace
.getNbEvents() || context
.getRank() == stopRank
) {
203 if (context
.getRank() % trace
.getCacheSize() == 1) {
204 // break for UI refresh
208 // timeAnalysisEntry.setLastRank(Math.min(trace.getNbEvents(),
210 timeAnalysisEntry
.setLastRank(context
.getRank());
214 if (context
!= null) {
219 private void refreshViewer() {
220 synchronized (fSyncObj
) {
222 fRefreshPending
= true;
227 // Perform the refresh on the UI thread
228 Display
.getDefault().asyncExec(new Runnable() {
231 if (fViewer
.getControl().isDisposed()) {
234 fViewer
.setInput(fTimeAnalysisEntries
.toArray(new TimeChartAnalysisEntry
[0]));
235 fViewer
.resetStartFinishTime();
236 synchronized (fSyncObj
) {
237 fRefreshBusy
= false;
238 if (fRefreshPending
) {
239 fRefreshPending
= false;
247 private void redrawViewer(boolean resetTimeIntervals
) {
248 synchronized (fSyncObj
) {
250 fRedrawPending
= true;
255 final boolean reset
= resetTimeIntervals
;
256 // Perform the refresh on the UI thread
257 Display
.getDefault().asyncExec(new Runnable() {
260 if (fViewer
.getControl().isDisposed()) {
264 fViewer
.setTimeRange(fTimeAnalysisEntries
.toArray(new TimeChartAnalysisEntry
[0]));
265 fViewer
.setTimeBounds();
267 fViewer
.getControl().redraw();
268 fViewer
.getControl().update();
269 synchronized (fSyncObj
) {
271 if (fRedrawPending
) {
272 fRedrawPending
= false;
280 private void itemize(long startTime
, long stopTime
) {
281 for (int i
= 0; i
< fTimeAnalysisEntries
.size(); i
++) {
282 Thread thread
= new ItemizeThread(fTimeAnalysisEntries
.get(i
), startTime
, stopTime
);
287 private class ItemizeThread
extends Thread
{
289 private final TimeChartAnalysisEntry fTimeAnalysisEntry
;
290 private final long startTime
;
291 private final long stopTime
;
292 private final long fMaxDuration
;
294 private ItemizeThread(TimeChartAnalysisEntry timeAnalysisEntry
, long startTime
, long stopTime
) {
295 super("Itemize Thread:" + timeAnalysisEntry
.getName()); //$NON-NLS-1$
296 fTimeAnalysisEntry
= timeAnalysisEntry
;
297 this.startTime
= startTime
;
298 this.stopTime
= stopTime
;
299 fMaxDuration
= 3 * (stopTime
- startTime
) / fDisplayWidth
;
304 itemizeTraceEntry(fTimeAnalysisEntry
);
307 public void itemizeTraceEntry(TimeChartAnalysisEntry timeAnalysisEntry
) {
308 Iterator
<ITimeEvent
> iterator
= timeAnalysisEntry
.getTimeEventsIterator();
309 TimeChartEvent event
= null;
310 boolean hasNext
= true;
312 synchronized (timeAnalysisEntry
) {
313 while ((hasNext
= iterator
.hasNext()) == true) {
314 event
= (TimeChartEvent
) iterator
.next();
315 if (event
.getTime() + event
.getDuration() > startTime
&& event
.getTime() < stopTime
&& event
.getDuration() > fMaxDuration
316 && event
.getNbEvents() > 1) {
321 if (hasNext
&& event
!= null) {
322 if (event
.getItemizedEntry() == null) {
325 itemizeTraceEntry(event
.getItemizedEntry());
331 public void itemizeEvent(TimeChartEvent event
) {
332 synchronized (event
) {
333 if (event
.isItemizing()) {
336 event
.setItemizing(true);
338 TimeChartAnalysisEntry timeAnalysisEntry
= new TimeChartAnalysisEntry(fTimeAnalysisEntry
.getTrace(), (int) Math
.min(
339 event
.getNbEvents() + 1, fDisplayWidth
* 2));
340 synchronized (event
.getRankRangeList()) {
341 for (RankRange range
: event
.getRankRangeList()) {
342 timeAnalysisEntry
.setLastRank(range
.getFirstRank());
343 updateTraceEntry(timeAnalysisEntry
, range
.getLastRank() + 1, event
.getTime(), event
.getTime() + event
.getDuration());
346 event
.setItemizedEntry(timeAnalysisEntry
);
348 itemizeTraceEntry(timeAnalysisEntry
);
349 synchronized (event
) {
350 event
.setItemizing(false);
355 private void redecorate() {
356 synchronized (fDecorateThreads
) {
357 for (DecorateThread thread
: fDecorateThreads
) {
360 fDecorateThreads
.clear();
361 for (int i
= 0; i
< fTimeAnalysisEntries
.size(); i
++) {
362 DecorateThread thread
= new DecorateThread(fTimeAnalysisEntries
.get(i
));
364 fDecorateThreads
.add(thread
);
369 private class DecorateThread
extends Thread
{
370 private volatile boolean interrupted
= false;
371 private final TimeChartAnalysisEntry fTimeAnalysisEntry
;
372 private final TimeChartDecorationProvider fDecorationProvider
;
373 private ITmfContext fContext
;
374 private int fCount
= 0;
376 private DecorateThread(TimeChartAnalysisEntry timeAnalysisEntry
) {
377 super("Decorate Thread:" + timeAnalysisEntry
.getName()); //$NON-NLS-1$
378 fTimeAnalysisEntry
= timeAnalysisEntry
;
379 fDecorationProvider
= fDecorationProviders
.get(timeAnalysisEntry
.getTrace());
384 resetTraceEntry(fTimeAnalysisEntry
);
386 decorateTraceEntry(fTimeAnalysisEntry
, null);
388 synchronized (fDecorateThreads
) {
389 fDecorateThreads
.remove(this);
391 if (fContext
!= null) {
396 public void resetTraceEntry(TimeChartAnalysisEntry timeAnalysisEntry
) {
397 Iterator
<ITimeEvent
> iterator
= timeAnalysisEntry
.getTimeEventsIterator();
398 TimeChartEvent event
= null;
399 boolean hasNext
= true;
400 while (!interrupted
&& hasNext
) {
401 synchronized (timeAnalysisEntry
) {
402 while ((hasNext
= iterator
.hasNext()) == true) {
403 event
= (TimeChartEvent
) iterator
.next();
407 if (hasNext
&& event
!= null) {
408 // TODO possible concurrency problem here with ItemizeJob
409 event
.setColorSettingPriority(ColorSettingsManager
.PRIORITY_NONE
);
410 if (event
.getItemizedEntry() != null) {
411 resetTraceEntry(event
.getItemizedEntry());
417 public void decorateTraceEntry(TimeChartAnalysisEntry timeAnalysisEntry
, TimeChartEvent parentEvent
) {
418 // Set max duration high to ensure iterator does not consider
420 Iterator
<ITimeEvent
> iterator
= timeAnalysisEntry
.getTimeEventsIterator(0, Long
.MAX_VALUE
, Long
.MAX_VALUE
);
421 TimeChartEvent event
= null;
422 int entryPriority
= ColorSettingsManager
.PRIORITY_NONE
;
423 boolean entryIsBookmarked
= false;
424 boolean entryIsVisible
= false;
425 boolean entryIsSearchMatch
= false;
426 boolean hasNext
= true;
427 while (!interrupted
&& hasNext
) {
428 synchronized (timeAnalysisEntry
) {
429 while ((hasNext
= iterator
.hasNext()) == true) {
430 event
= (TimeChartEvent
) iterator
.next();
434 if (hasNext
&& event
!= null) {
435 // TODO possible concurrency problem here with ItemizeJob
436 if (event
.getItemizedEntry() == null) {
437 decorateEvent(event
);
439 decorateTraceEntry(event
.getItemizedEntry(), event
);
441 entryPriority
= Math
.min(entryPriority
, event
.getColorSettingPriority());
442 entryIsBookmarked
|= event
.isBookmarked();
443 entryIsVisible
|= event
.isVisible();
444 entryIsSearchMatch
|= event
.isSearchMatch();
445 if (++fCount
% timeAnalysisEntry
.getTrace().getCacheSize() == 0) {
450 if (parentEvent
!= null) {
451 parentEvent
.setColorSettingPriority(entryPriority
);
452 parentEvent
.setIsBookmarked(entryIsBookmarked
);
453 parentEvent
.setIsVisible(entryIsVisible
);
454 parentEvent
.setIsSearchMatch(entryIsSearchMatch
);
458 public void decorateEvent(TimeChartEvent timeChartEvent
) {
459 // TODO possible concurrency problem here with ItemizeJob
460 TimeChartAnalysisEntry timeAnalysisEntry
= (TimeChartAnalysisEntry
) timeChartEvent
.getEntry();
461 ITmfTrace trace
= timeAnalysisEntry
.getTrace();
462 int priority
= ColorSettingsManager
.PRIORITY_NONE
;
463 boolean isBookmarked
= false;
464 boolean isVisible
= false;
465 boolean isSearchMatch
= false;
466 synchronized (timeChartEvent
.getRankRangeList()) {
467 for (RankRange range
: timeChartEvent
.getRankRangeList()) {
471 if (fContext
== null || fContext
.getRank() != range
.getFirstRank()) {
472 if (fContext
!= null) {
475 fContext
= trace
.seekEvent(range
.getFirstRank());
476 fContext
.setRank(range
.getFirstRank());
482 long rank
= fContext
.getRank();
483 ITmfEvent event
= trace
.getNext(fContext
);
487 long eventTime
= event
.getTimestamp().normalize(0, ITmfTimestamp
.NANOSECOND_SCALE
).getValue();
488 if (eventTime
>= timeChartEvent
.getTime() && eventTime
<= timeChartEvent
.getTime() + timeChartEvent
.getDuration()) {
489 priority
= Math
.min(priority
, ColorSettingsManager
.getColorSettingPriority(event
));
491 isBookmarked
|= fDecorationProvider
.isBookmark(rank
);
492 isVisible
|= fDecorationProvider
.isVisible(event
);
493 isSearchMatch
|= fDecorationProvider
.isSearchMatch(event
);
494 if (fContext
.getRank() > range
.getLastRank()) {
500 timeChartEvent
.setColorSettingPriority(priority
);
501 timeChartEvent
.setIsBookmarked(isBookmarked
);
502 timeChartEvent
.setIsVisible(isVisible
);
503 timeChartEvent
.setIsSearchMatch(isSearchMatch
);
506 public void cancel() {
511 // ------------------------------------------------------------------------
513 // ------------------------------------------------------------------------
516 public void timeRangeUpdated(TimeGraphRangeUpdateEvent event
) {
517 fStartTime
= event
.getStartTime();
518 fStopTime
= event
.getEndTime();
519 itemize(fStartTime
, fStopTime
);
520 final ITmfTimestamp startTimestamp
= new TmfTimestamp(event
.getStartTime(), ITmfTimestamp
.NANOSECOND_SCALE
);
521 final ITmfTimestamp endTimestamp
= new TmfTimestamp(event
.getEndTime(), ITmfTimestamp
.NANOSECOND_SCALE
);
522 TmfTimeRange range
= new TmfTimeRange(startTimestamp
, endTimestamp
);
523 broadcast(new TmfRangeSynchSignal(this, range
));
527 public void selectionChanged(TimeGraphSelectionEvent event
) {
528 ITimeGraphEntry timeAnalysisEntry
= null;
529 if (event
.getSelection() instanceof TimeChartAnalysisEntry
) {
530 timeAnalysisEntry
= event
.getSelection();
531 } else if (event
.getSelection() instanceof TimeChartEvent
) {
532 timeAnalysisEntry
= ((TimeChartEvent
) event
.getSelection()).getEntry();
534 if (timeAnalysisEntry
instanceof TimeChartAnalysisEntry
) {
535 broadcast(new TmfTraceSelectedSignal(this, ((TimeChartAnalysisEntry
) timeAnalysisEntry
).getTrace()));
540 public void timeSelected(TimeGraphTimeEvent event
) {
541 broadcast(new TmfTimeSynchSignal(this, new TmfTimestamp(event
.getBeginTime(), TIMESTAMP_SCALE
), new TmfTimestamp(event
.getEndTime(), TIMESTAMP_SCALE
)));
545 public void colorSettingsChanged(ColorSetting
[] colorSettings
) {
546 // Set presentation provider again to trigger re-creation of new color settings which are stored
547 // in the TimeGraphControl class
548 fViewer
.setTimeGraphProvider(fPresentationProvider
);
553 public void resourceChanged(IResourceChangeEvent event
) {
554 for (IMarkerDelta delta
: event
.findMarkerDeltas(IMarker
.BOOKMARK
, false)) {
555 for (TimeChartDecorationProvider provider
: fDecorationProviders
.values()) {
556 if (delta
.getResource().equals(provider
.getBookmarksFile())) {
557 if (delta
.getKind() == IResourceDelta
.CHANGED
&& delta
.getMarker().getAttribute(IMarker
.LOCATION
, -1) != -1) {
558 provider
.refreshBookmarks();
559 } else if (delta
.getKind() == IResourceDelta
.REMOVED
) {
560 provider
.refreshBookmarks();
568 // ------------------------------------------------------------------------
570 // ------------------------------------------------------------------------
573 * Handler for the Trace Opened signal
576 * The incoming signal
579 public void traceOpened(TmfTraceOpenedSignal signal
) {
580 final ITmfTrace trace
= signal
.getTrace();
581 final IFile bookmarksFile
= signal
.getEditorFile();
582 TimeChartAnalysisEntry timeAnalysisEntry
= null;
583 for (int i
= 0; i
< fTimeAnalysisEntries
.size(); i
++) {
584 if (fTimeAnalysisEntries
.get(i
).getTrace().equals(trace
)) {
585 timeAnalysisEntry
= fTimeAnalysisEntries
.get(i
);
589 if (timeAnalysisEntry
== null) {
590 timeAnalysisEntry
= new TimeChartAnalysisEntry(trace
, fDisplayWidth
* 2);
591 fTimeAnalysisEntries
.add(timeAnalysisEntry
);
592 fDecorationProviders
.put(trace
, new TimeChartDecorationProvider(bookmarksFile
));
593 Thread thread
= new ProcessTraceThread(timeAnalysisEntry
);
600 * Handler for the Trace Closed signal
603 * The incoming signal
606 public void traceClosed(TmfTraceClosedSignal signal
) {
607 final ITmfTrace trace
= signal
.getTrace();
608 for (int i
= 0; i
< fTimeAnalysisEntries
.size(); i
++) {
609 if (fTimeAnalysisEntries
.get(i
).getTrace().equals(trace
)) {
610 fTimeAnalysisEntries
.remove(i
);
611 fDecorationProviders
.remove(trace
);
612 synchronized (fDecorateThreads
) {
613 for (DecorateThread thread
: fDecorateThreads
) {
614 if (thread
.fTimeAnalysisEntry
.getTrace() == trace
) {
616 fDecorateThreads
.remove(thread
);
628 * Handler for the Trace Selected signal
631 * The incoming signal
634 public void traceSelected(TmfTraceSelectedSignal signal
) {
635 if (signal
.getSource() != this) {
636 ITmfTrace trace
= signal
.getTrace();
637 for (int i
= 0; i
< fTimeAnalysisEntries
.size(); i
++) {
638 if (fTimeAnalysisEntries
.get(i
).getTrace().equals(trace
)) {
639 fViewer
.setSelection(fTimeAnalysisEntries
.get(i
));
643 TmfTraceContext ctx
= TmfTraceManager
.getInstance().getCurrentTraceContext();
644 long beginTime
= ctx
.getSelectionRange().getStartTime().normalize(0, ITmfTimestamp
.NANOSECOND_SCALE
).getValue();
645 long endTime
= ctx
.getSelectionRange().getEndTime().normalize(0, ITmfTimestamp
.NANOSECOND_SCALE
).getValue();
646 fViewer
.setSelectionRange(beginTime
, endTime
);
651 * Handler for the Trace Updated signal
654 * The incoming signal
657 public void traceUpdated(TmfTraceUpdatedSignal signal
) {
658 final ITmfTrace trace
= signal
.getTrace();
659 for (int i
= 0; i
< fTimeAnalysisEntries
.size(); i
++) {
660 TimeChartAnalysisEntry timeAnalysisEntry
= fTimeAnalysisEntries
.get(i
);
661 if (timeAnalysisEntry
.getTrace().equals(trace
)) {
662 updateTraceEntry(timeAnalysisEntry
, Long
.MAX_VALUE
, 0, Long
.MAX_VALUE
);
669 * Handler for the Time Synch signal
672 * The incoming signal
675 public void currentTimeUpdated(TmfTimeSynchSignal signal
) {
676 final long beginTime
= signal
.getBeginTime().normalize(0, TIMESTAMP_SCALE
).getValue();
677 final long endTime
= signal
.getEndTime().normalize(0, TIMESTAMP_SCALE
).getValue();
678 Display
.getDefault().asyncExec(new Runnable() {
681 if (beginTime
== endTime
) {
682 fViewer
.setSelectedTime(beginTime
, true);
683 if (fStartTime
!= fViewer
.getTime0() || fStopTime
!= fViewer
.getTime1()) {
684 fStartTime
= fViewer
.getTime0();
685 fStopTime
= fViewer
.getTime1();
686 itemize(fStartTime
, fStopTime
);
689 fViewer
.setSelectionRange(beginTime
, endTime
);
696 * Handler for the Time Range Synch signal
699 * The incoming signal
702 public void synchToRange(final TmfRangeSynchSignal signal
) {
703 if (signal
.getSource() == this) {
706 final long startTime
= signal
.getCurrentRange().getStartTime().normalize(0, ITmfTimestamp
.NANOSECOND_SCALE
).getValue();
707 final long endTime
= signal
.getCurrentRange().getEndTime().normalize(0, ITmfTimestamp
.NANOSECOND_SCALE
).getValue();
708 Display
.getDefault().asyncExec(new Runnable() {
711 fStartTime
= startTime
;
713 itemize(fStartTime
, fStopTime
);
714 fViewer
.setStartFinishTime(startTime
, endTime
);
720 * Handler for the Event Filter Applied signal
723 * The incoming signal
726 public void filterApplied(TmfEventFilterAppliedSignal signal
) {
727 TimeChartDecorationProvider decorationProvider
= fDecorationProviders
.get(signal
.getTrace());
728 if (decorationProvider
== null) {
731 decorationProvider
.filterApplied(signal
.getEventFilter());
736 * Handler for the Event Search Applied signal
739 * The incoming signal
742 public void searchApplied(TmfEventSearchAppliedSignal signal
) {
743 TimeChartDecorationProvider decorationProvider
= fDecorationProviders
.get(signal
.getTrace());
744 if (decorationProvider
== null) {
747 decorationProvider
.searchApplied(signal
.getSearchFilter());