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
.TmfTraceManager
;
47 import org
.eclipse
.tracecompass
.tmf
.ui
.views
.TmfView
;
48 import org
.eclipse
.tracecompass
.tmf
.ui
.views
.colors
.ColorSetting
;
49 import org
.eclipse
.tracecompass
.tmf
.ui
.views
.colors
.ColorSettingsManager
;
50 import org
.eclipse
.tracecompass
.tmf
.ui
.views
.colors
.IColorSettingsListener
;
51 import org
.eclipse
.tracecompass
.tmf
.ui
.views
.timechart
.TimeChartEvent
.RankRange
;
52 import org
.eclipse
.tracecompass
.tmf
.ui
.widgets
.timegraph
.ITimeGraphPresentationProvider
;
53 import org
.eclipse
.tracecompass
.tmf
.ui
.widgets
.timegraph
.ITimeGraphRangeListener
;
54 import org
.eclipse
.tracecompass
.tmf
.ui
.widgets
.timegraph
.ITimeGraphSelectionListener
;
55 import org
.eclipse
.tracecompass
.tmf
.ui
.widgets
.timegraph
.ITimeGraphTimeListener
;
56 import org
.eclipse
.tracecompass
.tmf
.ui
.widgets
.timegraph
.TimeGraphRangeUpdateEvent
;
57 import org
.eclipse
.tracecompass
.tmf
.ui
.widgets
.timegraph
.TimeGraphSelectionEvent
;
58 import org
.eclipse
.tracecompass
.tmf
.ui
.widgets
.timegraph
.TimeGraphTimeEvent
;
59 import org
.eclipse
.tracecompass
.tmf
.ui
.widgets
.timegraph
.TimeGraphViewer
;
60 import org
.eclipse
.tracecompass
.tmf
.ui
.widgets
.timegraph
.model
.ITimeEvent
;
61 import org
.eclipse
.tracecompass
.tmf
.ui
.widgets
.timegraph
.model
.ITimeGraphEntry
;
62 import org
.eclipse
.tracecompass
.tmf
.ui
.widgets
.timegraph
.widgets
.Utils
.TimeFormat
;
65 * Generic Time Chart view, which is similar to a Gantt chart for trace analysis
68 * @author Patrick Tasse
70 public class TimeChartView
extends TmfView
implements ITimeGraphRangeListener
, ITimeGraphSelectionListener
, ITimeGraphTimeListener
, IColorSettingsListener
, IResourceChangeListener
{
72 /** TimeChartView's ID */
73 public static final String ID
= "org.eclipse.linuxtools.tmf.ui.views.timechart"; //$NON-NLS-1$
75 private static final int TIMESTAMP_SCALE
= -9;
77 private final int fDisplayWidth
;
78 private TimeGraphViewer fViewer
;
79 private final ArrayList
<TimeChartAnalysisEntry
> fTimeAnalysisEntries
= new ArrayList
<>();
80 private final Map
<ITmfTrace
, TimeChartDecorationProvider
> fDecorationProviders
= new HashMap
<>();
81 private final ArrayList
<DecorateThread
> fDecorateThreads
= new ArrayList
<>();
82 private long fStartTime
= 0;
83 private long fStopTime
= Long
.MAX_VALUE
;
84 private boolean fRefreshBusy
= false;
85 private boolean fRefreshPending
= false;
86 private boolean fRedrawBusy
= false;
87 private boolean fRedrawPending
= false;
88 private final Object fSyncObj
= new Object();
89 private ITimeGraphPresentationProvider fPresentationProvider
;
94 public TimeChartView() {
95 super("Time Chart"); //$NON-NLS-1$
96 fDisplayWidth
= Display
.getDefault().getBounds().width
;
100 public void createPartControl(Composite parent
) {
101 fViewer
= new TimeGraphViewer(parent
, SWT
.NONE
);
102 fPresentationProvider
= new TimeChartAnalysisProvider();
103 fViewer
.setTimeGraphProvider(fPresentationProvider
);
104 fViewer
.setTimeFormat(TimeFormat
.CALENDAR
);
105 fViewer
.addTimeListener(this);
106 fViewer
.addRangeListener(this);
107 fViewer
.addSelectionListener(this);
108 fViewer
.setMinimumItemWidth(1);
110 IStatusLineManager statusLineManager
= getViewSite().getActionBars().getStatusLineManager();
111 fViewer
.getTimeGraphControl().setStatusLineManager(statusLineManager
);
113 for (ITmfTrace trace
: TmfTraceManager
.getInstance().getOpenedTraces()) {
114 IFile bookmarksFile
= TmfTraceManager
.getInstance().getTraceEditorFile(trace
);
115 TimeChartAnalysisEntry timeAnalysisEntry
= new TimeChartAnalysisEntry(trace
, fDisplayWidth
* 2);
116 fTimeAnalysisEntries
.add(timeAnalysisEntry
);
117 fDecorationProviders
.put(trace
, new TimeChartDecorationProvider(bookmarksFile
));
118 Thread thread
= new ProcessTraceThread(timeAnalysisEntry
);
121 fViewer
.setInput(fTimeAnalysisEntries
.toArray(new TimeChartAnalysisEntry
[0]));
123 ColorSettingsManager
.addColorSettingsListener(this);
124 ResourcesPlugin
.getWorkspace().addResourceChangeListener(this, IResourceChangeEvent
.POST_CHANGE
);
128 public void dispose() {
129 ResourcesPlugin
.getWorkspace().removeResourceChangeListener(this);
130 for (DecorateThread thread
: fDecorateThreads
) {
133 ColorSettingsManager
.removeColorSettingsListener(this);
138 public void setFocus() {
142 private class ProcessTraceThread
extends Thread
{
144 private final TimeChartAnalysisEntry fTimeAnalysisEntry
;
146 public ProcessTraceThread(TimeChartAnalysisEntry timeAnalysisEntry
) {
147 super("ProcessTraceJob:" + timeAnalysisEntry
.getName()); //$NON-NLS-1$
148 fTimeAnalysisEntry
= timeAnalysisEntry
;
153 updateTraceEntry(fTimeAnalysisEntry
, Long
.MAX_VALUE
, 0, Long
.MAX_VALUE
);
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
163 ITmfContext context
= null;
164 // TmfTimestamp lastTimestamp = null;
165 boolean done
= false;
167 synchronized (timeAnalysisEntry
) {
168 if (timeAnalysisEntry
.getLastRank() >= trace
.getNbEvents()) {
172 if (context
== null || context
.getRank() != timeAnalysisEntry
.getLastRank()) {
173 if (context
!= null) {
176 if (timeAnalysisEntry
.getLastRank() != -1) {
177 context
= trace
.seekEvent(timeAnalysisEntry
.getLastRank());
179 // context = trace.seekLocation(null);
180 context
= trace
.seekEvent(0);
184 long rank
= context
.getRank();
185 ITmfEvent event
= trace
.getNext(context
);
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
);
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
) {
202 if (context
.getRank() % trace
.getCacheSize() == 1) {
203 // break for UI refresh
207 // timeAnalysisEntry.setLastRank(Math.min(trace.getNbEvents(),
209 timeAnalysisEntry
.setLastRank(context
.getRank());
213 if (context
!= null) {
218 private void refreshViewer() {
219 synchronized (fSyncObj
) {
221 fRefreshPending
= true;
226 // Perform the refresh on the UI thread
227 Display
.getDefault().asyncExec(new Runnable() {
230 if (fViewer
.getControl().isDisposed()) {
233 fViewer
.setInput(fTimeAnalysisEntries
.toArray(new TimeChartAnalysisEntry
[0]));
234 fViewer
.resetStartFinishTime();
235 synchronized (fSyncObj
) {
236 fRefreshBusy
= false;
237 if (fRefreshPending
) {
238 fRefreshPending
= false;
246 private void redrawViewer(boolean resetTimeIntervals
) {
247 synchronized (fSyncObj
) {
249 fRedrawPending
= true;
254 final boolean reset
= resetTimeIntervals
;
255 // Perform the refresh on the UI thread
256 Display
.getDefault().asyncExec(new Runnable() {
259 if (fViewer
.getControl().isDisposed()) {
263 fViewer
.setTimeRange(fTimeAnalysisEntries
.toArray(new TimeChartAnalysisEntry
[0]));
264 fViewer
.setTimeBounds();
266 fViewer
.getControl().redraw();
267 fViewer
.getControl().update();
268 synchronized (fSyncObj
) {
270 if (fRedrawPending
) {
271 fRedrawPending
= false;
279 private void itemize(long startTime
, long stopTime
) {
280 for (int i
= 0; i
< fTimeAnalysisEntries
.size(); i
++) {
281 Thread thread
= new ItemizeThread(fTimeAnalysisEntries
.get(i
), startTime
, stopTime
);
286 private class ItemizeThread
extends Thread
{
288 private final TimeChartAnalysisEntry fTimeAnalysisEntry
;
289 private final long startTime
;
290 private final long stopTime
;
291 private final long fMaxDuration
;
293 private ItemizeThread(TimeChartAnalysisEntry timeAnalysisEntry
, long startTime
, long stopTime
) {
294 super("Itemize Thread:" + timeAnalysisEntry
.getName()); //$NON-NLS-1$
295 fTimeAnalysisEntry
= timeAnalysisEntry
;
296 this.startTime
= startTime
;
297 this.stopTime
= stopTime
;
298 fMaxDuration
= 3 * (stopTime
- startTime
) / fDisplayWidth
;
303 itemizeTraceEntry(fTimeAnalysisEntry
);
306 public void itemizeTraceEntry(TimeChartAnalysisEntry timeAnalysisEntry
) {
307 Iterator
<ITimeEvent
> iterator
= timeAnalysisEntry
.getTimeEventsIterator();
308 TimeChartEvent event
= null;
309 boolean hasNext
= true;
311 synchronized (timeAnalysisEntry
) {
312 while ((hasNext
= iterator
.hasNext()) == true) {
313 event
= (TimeChartEvent
) iterator
.next();
314 if (event
.getTime() + event
.getDuration() > startTime
&& event
.getTime() < stopTime
&& event
.getDuration() > fMaxDuration
315 && event
.getNbEvents() > 1) {
320 if (hasNext
&& event
!= null) {
321 if (event
.getItemizedEntry() == null) {
324 itemizeTraceEntry(event
.getItemizedEntry());
330 public void itemizeEvent(TimeChartEvent event
) {
331 synchronized (event
) {
332 if (event
.isItemizing()) {
335 event
.setItemizing(true);
337 TimeChartAnalysisEntry timeAnalysisEntry
= new TimeChartAnalysisEntry(fTimeAnalysisEntry
.getTrace(), (int) Math
.min(
338 event
.getNbEvents() + 1, fDisplayWidth
* 2));
339 synchronized (event
.getRankRangeList()) {
340 for (RankRange range
: event
.getRankRangeList()) {
341 timeAnalysisEntry
.setLastRank(range
.getFirstRank());
342 updateTraceEntry(timeAnalysisEntry
, range
.getLastRank() + 1, event
.getTime(), event
.getTime() + event
.getDuration());
345 event
.setItemizedEntry(timeAnalysisEntry
);
347 itemizeTraceEntry(timeAnalysisEntry
);
348 synchronized (event
) {
349 event
.setItemizing(false);
354 private void redecorate() {
355 synchronized (fDecorateThreads
) {
356 for (DecorateThread thread
: fDecorateThreads
) {
359 fDecorateThreads
.clear();
360 for (int i
= 0; i
< fTimeAnalysisEntries
.size(); i
++) {
361 DecorateThread thread
= new DecorateThread(fTimeAnalysisEntries
.get(i
));
363 fDecorateThreads
.add(thread
);
368 private class DecorateThread
extends Thread
{
369 private volatile boolean interrupted
= false;
370 private final TimeChartAnalysisEntry fTimeAnalysisEntry
;
371 private final TimeChartDecorationProvider fDecorationProvider
;
372 private ITmfContext fContext
;
373 private int fCount
= 0;
375 private DecorateThread(TimeChartAnalysisEntry timeAnalysisEntry
) {
376 super("Decorate Thread:" + timeAnalysisEntry
.getName()); //$NON-NLS-1$
377 fTimeAnalysisEntry
= timeAnalysisEntry
;
378 fDecorationProvider
= fDecorationProviders
.get(timeAnalysisEntry
.getTrace());
383 resetTraceEntry(fTimeAnalysisEntry
);
385 decorateTraceEntry(fTimeAnalysisEntry
, null);
387 synchronized (fDecorateThreads
) {
388 fDecorateThreads
.remove(this);
390 if (fContext
!= null) {
395 public void resetTraceEntry(TimeChartAnalysisEntry timeAnalysisEntry
) {
396 Iterator
<ITimeEvent
> iterator
= timeAnalysisEntry
.getTimeEventsIterator();
397 TimeChartEvent event
= null;
398 boolean hasNext
= true;
399 while (!interrupted
&& hasNext
) {
400 synchronized (timeAnalysisEntry
) {
401 while ((hasNext
= iterator
.hasNext()) == true) {
402 event
= (TimeChartEvent
) iterator
.next();
406 if (hasNext
&& event
!= null) {
407 // TODO possible concurrency problem here with ItemizeJob
408 event
.setColorSettingPriority(ColorSettingsManager
.PRIORITY_NONE
);
409 if (event
.getItemizedEntry() != null) {
410 resetTraceEntry(event
.getItemizedEntry());
416 public void decorateTraceEntry(TimeChartAnalysisEntry timeAnalysisEntry
, TimeChartEvent parentEvent
) {
417 // Set max duration high to ensure iterator does not consider
419 Iterator
<ITimeEvent
> iterator
= timeAnalysisEntry
.getTimeEventsIterator(0, Long
.MAX_VALUE
, Long
.MAX_VALUE
);
420 TimeChartEvent event
= null;
421 int entryPriority
= ColorSettingsManager
.PRIORITY_NONE
;
422 boolean entryIsBookmarked
= false;
423 boolean entryIsVisible
= false;
424 boolean entryIsSearchMatch
= false;
425 boolean hasNext
= true;
426 while (!interrupted
&& hasNext
) {
427 synchronized (timeAnalysisEntry
) {
428 while ((hasNext
= iterator
.hasNext()) == true) {
429 event
= (TimeChartEvent
) iterator
.next();
433 if (hasNext
&& event
!= null) {
434 // TODO possible concurrency problem here with ItemizeJob
435 if (event
.getItemizedEntry() == null) {
436 decorateEvent(event
);
438 decorateTraceEntry(event
.getItemizedEntry(), event
);
440 entryPriority
= Math
.min(entryPriority
, event
.getColorSettingPriority());
441 entryIsBookmarked
|= event
.isBookmarked();
442 entryIsVisible
|= event
.isVisible();
443 entryIsSearchMatch
|= event
.isSearchMatch();
444 if (++fCount
% timeAnalysisEntry
.getTrace().getCacheSize() == 0) {
449 if (parentEvent
!= null) {
450 parentEvent
.setColorSettingPriority(entryPriority
);
451 parentEvent
.setIsBookmarked(entryIsBookmarked
);
452 parentEvent
.setIsVisible(entryIsVisible
);
453 parentEvent
.setIsSearchMatch(entryIsSearchMatch
);
457 public void decorateEvent(TimeChartEvent timeChartEvent
) {
458 // TODO possible concurrency problem here with ItemizeJob
459 TimeChartAnalysisEntry timeAnalysisEntry
= (TimeChartAnalysisEntry
) timeChartEvent
.getEntry();
460 ITmfTrace trace
= timeAnalysisEntry
.getTrace();
461 int priority
= ColorSettingsManager
.PRIORITY_NONE
;
462 boolean isBookmarked
= false;
463 boolean isVisible
= false;
464 boolean isSearchMatch
= false;
465 synchronized (timeChartEvent
.getRankRangeList()) {
466 for (RankRange range
: timeChartEvent
.getRankRangeList()) {
470 if (fContext
== null || fContext
.getRank() != range
.getFirstRank()) {
471 if (fContext
!= null) {
474 fContext
= trace
.seekEvent(range
.getFirstRank());
475 fContext
.setRank(range
.getFirstRank());
481 long rank
= fContext
.getRank();
482 ITmfEvent event
= trace
.getNext(fContext
);
486 long eventTime
= event
.getTimestamp().normalize(0, ITmfTimestamp
.NANOSECOND_SCALE
).getValue();
487 if (eventTime
>= timeChartEvent
.getTime() && eventTime
<= timeChartEvent
.getTime() + timeChartEvent
.getDuration()) {
488 priority
= Math
.min(priority
, ColorSettingsManager
.getColorSettingPriority(event
));
490 isBookmarked
|= fDecorationProvider
.isBookmark(rank
);
491 isVisible
|= fDecorationProvider
.isVisible(event
);
492 isSearchMatch
|= fDecorationProvider
.isSearchMatch(event
);
493 if (fContext
.getRank() > range
.getLastRank()) {
499 timeChartEvent
.setColorSettingPriority(priority
);
500 timeChartEvent
.setIsBookmarked(isBookmarked
);
501 timeChartEvent
.setIsVisible(isVisible
);
502 timeChartEvent
.setIsSearchMatch(isSearchMatch
);
505 public void cancel() {
510 // ------------------------------------------------------------------------
512 // ------------------------------------------------------------------------
515 public void timeRangeUpdated(TimeGraphRangeUpdateEvent event
) {
516 fStartTime
= event
.getStartTime();
517 fStopTime
= event
.getEndTime();
518 itemize(fStartTime
, fStopTime
);
519 final ITmfTimestamp startTimestamp
= new TmfTimestamp(event
.getStartTime(), ITmfTimestamp
.NANOSECOND_SCALE
);
520 final ITmfTimestamp endTimestamp
= new TmfTimestamp(event
.getEndTime(), ITmfTimestamp
.NANOSECOND_SCALE
);
521 TmfTimeRange range
= new TmfTimeRange(startTimestamp
, endTimestamp
);
522 broadcast(new TmfRangeSynchSignal(this, range
));
526 public void selectionChanged(TimeGraphSelectionEvent event
) {
527 ITimeGraphEntry timeAnalysisEntry
= null;
528 if (event
.getSelection() instanceof TimeChartAnalysisEntry
) {
529 timeAnalysisEntry
= event
.getSelection();
530 } else if (event
.getSelection() instanceof TimeChartEvent
) {
531 timeAnalysisEntry
= ((TimeChartEvent
) event
.getSelection()).getEntry();
533 if (timeAnalysisEntry
instanceof TimeChartAnalysisEntry
) {
534 broadcast(new TmfTraceSelectedSignal(this, ((TimeChartAnalysisEntry
) timeAnalysisEntry
).getTrace()));
539 public void timeSelected(TimeGraphTimeEvent event
) {
540 broadcast(new TmfTimeSynchSignal(this, new TmfTimestamp(event
.getBeginTime(), TIMESTAMP_SCALE
), new TmfTimestamp(event
.getEndTime(), TIMESTAMP_SCALE
)));
544 public void colorSettingsChanged(ColorSetting
[] colorSettings
) {
545 // Set presentation provider again to trigger re-creation of new color settings which are stored
546 // in the TimeGraphControl class
547 fViewer
.setTimeGraphProvider(fPresentationProvider
);
552 public void resourceChanged(IResourceChangeEvent event
) {
553 for (IMarkerDelta delta
: event
.findMarkerDeltas(IMarker
.BOOKMARK
, false)) {
554 for (TimeChartDecorationProvider provider
: fDecorationProviders
.values()) {
555 if (delta
.getResource().equals(provider
.getBookmarksFile())) {
556 if (delta
.getKind() == IResourceDelta
.CHANGED
&& delta
.getMarker().getAttribute(IMarker
.LOCATION
, -1) != -1) {
557 provider
.refreshBookmarks();
558 } else if (delta
.getKind() == IResourceDelta
.REMOVED
) {
559 provider
.refreshBookmarks();
567 // ------------------------------------------------------------------------
569 // ------------------------------------------------------------------------
572 * Handler for the Trace Opened signal
575 * The incoming signal
578 public void traceOpened(TmfTraceOpenedSignal signal
) {
579 final ITmfTrace trace
= signal
.getTrace();
580 final IFile bookmarksFile
= signal
.getEditorFile();
581 TimeChartAnalysisEntry timeAnalysisEntry
= null;
582 for (int i
= 0; i
< fTimeAnalysisEntries
.size(); i
++) {
583 if (fTimeAnalysisEntries
.get(i
).getTrace().equals(trace
)) {
584 timeAnalysisEntry
= fTimeAnalysisEntries
.get(i
);
588 if (timeAnalysisEntry
== null) {
589 timeAnalysisEntry
= new TimeChartAnalysisEntry(trace
, fDisplayWidth
* 2);
590 fTimeAnalysisEntries
.add(timeAnalysisEntry
);
591 fDecorationProviders
.put(trace
, new TimeChartDecorationProvider(bookmarksFile
));
592 Thread thread
= new ProcessTraceThread(timeAnalysisEntry
);
599 * Handler for the Trace Closed signal
602 * The incoming signal
605 public void traceClosed(TmfTraceClosedSignal signal
) {
606 final ITmfTrace trace
= signal
.getTrace();
607 for (int i
= 0; i
< fTimeAnalysisEntries
.size(); i
++) {
608 if (fTimeAnalysisEntries
.get(i
).getTrace().equals(trace
)) {
609 fTimeAnalysisEntries
.remove(i
);
610 fDecorationProviders
.remove(trace
);
611 synchronized (fDecorateThreads
) {
612 for (DecorateThread thread
: fDecorateThreads
) {
613 if (thread
.fTimeAnalysisEntry
.getTrace() == trace
) {
615 fDecorateThreads
.remove(thread
);
627 * Handler for the Trace Selected signal
630 * The incoming signal
633 public void traceSelected(TmfTraceSelectedSignal signal
) {
634 if (signal
.getSource() != this) {
635 ITmfTrace trace
= signal
.getTrace();
636 for (int i
= 0; i
< fTimeAnalysisEntries
.size(); i
++) {
637 if (fTimeAnalysisEntries
.get(i
).getTrace().equals(trace
)) {
638 fViewer
.setSelection(fTimeAnalysisEntries
.get(i
));
642 long beginTime
= fTraceManager
.getSelectionBeginTime().normalize(0, ITmfTimestamp
.NANOSECOND_SCALE
).getValue();
643 long endTime
= fTraceManager
.getSelectionEndTime().normalize(0, ITmfTimestamp
.NANOSECOND_SCALE
).getValue();
644 fViewer
.setSelectionRange(beginTime
, endTime
);
649 * Handler for the Trace Updated signal
652 * The incoming signal
655 public void traceUpdated(TmfTraceUpdatedSignal signal
) {
656 final ITmfTrace trace
= signal
.getTrace();
657 for (int i
= 0; i
< fTimeAnalysisEntries
.size(); i
++) {
658 TimeChartAnalysisEntry timeAnalysisEntry
= fTimeAnalysisEntries
.get(i
);
659 if (timeAnalysisEntry
.getTrace().equals(trace
)) {
660 updateTraceEntry(timeAnalysisEntry
, Long
.MAX_VALUE
, 0, Long
.MAX_VALUE
);
667 * Handler for the Time Synch signal
670 * The incoming signal
673 public void currentTimeUpdated(TmfTimeSynchSignal signal
) {
674 final long beginTime
= signal
.getBeginTime().normalize(0, TIMESTAMP_SCALE
).getValue();
675 final long endTime
= signal
.getEndTime().normalize(0, TIMESTAMP_SCALE
).getValue();
676 Display
.getDefault().asyncExec(new Runnable() {
679 if (beginTime
== endTime
) {
680 fViewer
.setSelectedTime(beginTime
, true);
681 if (fStartTime
!= fViewer
.getTime0() || fStopTime
!= fViewer
.getTime1()) {
682 fStartTime
= fViewer
.getTime0();
683 fStopTime
= fViewer
.getTime1();
684 itemize(fStartTime
, fStopTime
);
687 fViewer
.setSelectionRange(beginTime
, endTime
);
694 * Handler for the Time Range Synch signal
697 * The incoming signal
700 public void synchToRange(final TmfRangeSynchSignal signal
) {
701 if (signal
.getSource() == this) {
704 final long startTime
= signal
.getCurrentRange().getStartTime().normalize(0, ITmfTimestamp
.NANOSECOND_SCALE
).getValue();
705 final long endTime
= signal
.getCurrentRange().getEndTime().normalize(0, ITmfTimestamp
.NANOSECOND_SCALE
).getValue();
706 Display
.getDefault().asyncExec(new Runnable() {
709 fStartTime
= startTime
;
711 itemize(fStartTime
, fStopTime
);
712 fViewer
.setStartFinishTime(startTime
, endTime
);
718 * Handler for the Event Filter Applied signal
721 * The incoming signal
724 public void filterApplied(TmfEventFilterAppliedSignal signal
) {
725 TimeChartDecorationProvider decorationProvider
= fDecorationProviders
.get(signal
.getTrace());
726 if (decorationProvider
== null) {
729 decorationProvider
.filterApplied(signal
.getEventFilter());
734 * Handler for the Event Search Applied signal
737 * The incoming signal
740 public void searchApplied(TmfEventSearchAppliedSignal signal
) {
741 TimeChartDecorationProvider decorationProvider
= fDecorationProviders
.get(signal
.getTrace());
742 if (decorationProvider
== null) {
745 decorationProvider
.searchApplied(signal
.getSearchFilter());