1 /*******************************************************************************
2 * Copyright (c) 2010 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
.linuxtools
.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
.IMarker
;
21 import org
.eclipse
.core
.resources
.IMarkerDelta
;
22 import org
.eclipse
.core
.resources
.IResource
;
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
.TmfEvent
;
28 import org
.eclipse
.linuxtools
.tmf
.core
.event
.TmfTimestamp
;
29 import org
.eclipse
.linuxtools
.tmf
.core
.experiment
.TmfExperiment
;
30 import org
.eclipse
.linuxtools
.tmf
.core
.filter
.ITmfFilter
;
31 import org
.eclipse
.linuxtools
.tmf
.core
.signal
.TmfSignalHandler
;
32 import org
.eclipse
.linuxtools
.tmf
.core
.signal
.TmfTimeSynchSignal
;
33 import org
.eclipse
.linuxtools
.tmf
.core
.signal
.TmfTraceSelectedSignal
;
34 import org
.eclipse
.linuxtools
.tmf
.core
.signal
.TmfTraceUpdatedSignal
;
35 import org
.eclipse
.linuxtools
.tmf
.core
.trace
.ITmfTrace
;
36 import org
.eclipse
.linuxtools
.tmf
.core
.trace
.TmfContext
;
37 import org
.eclipse
.linuxtools
.tmf
.ui
.editors
.ITmfTraceEditor
;
38 import org
.eclipse
.linuxtools
.tmf
.ui
.signal
.TmfTraceClosedSignal
;
39 import org
.eclipse
.linuxtools
.tmf
.ui
.signal
.TmfTraceOpenedSignal
;
40 import org
.eclipse
.linuxtools
.tmf
.ui
.viewers
.TmfViewerFactory
;
41 import org
.eclipse
.linuxtools
.tmf
.ui
.viewers
.events
.ITmfEventsFilterListener
;
42 import org
.eclipse
.linuxtools
.tmf
.ui
.viewers
.events
.ITmfEventsFilterProvider
;
43 import org
.eclipse
.linuxtools
.tmf
.ui
.viewers
.timeAnalysis
.ITimeAnalysisViewer
;
44 import org
.eclipse
.linuxtools
.tmf
.ui
.viewers
.timeAnalysis
.ITmfTimeScaleSelectionListener
;
45 import org
.eclipse
.linuxtools
.tmf
.ui
.viewers
.timeAnalysis
.ITmfTimeSelectionListener
;
46 import org
.eclipse
.linuxtools
.tmf
.ui
.viewers
.timeAnalysis
.TmfTimeScaleSelectionEvent
;
47 import org
.eclipse
.linuxtools
.tmf
.ui
.viewers
.timeAnalysis
.TmfTimeSelectionEvent
;
48 import org
.eclipse
.linuxtools
.tmf
.ui
.viewers
.timeAnalysis
.model
.ITimeEvent
;
49 import org
.eclipse
.linuxtools
.tmf
.ui
.viewers
.timeAnalysis
.model
.ITmfTimeAnalysisEntry
;
50 import org
.eclipse
.linuxtools
.tmf
.ui
.views
.TmfView
;
51 import org
.eclipse
.linuxtools
.tmf
.ui
.views
.colors
.ColorSetting
;
52 import org
.eclipse
.linuxtools
.tmf
.ui
.views
.colors
.ColorSettingsManager
;
53 import org
.eclipse
.linuxtools
.tmf
.ui
.views
.colors
.IColorSettingsListener
;
54 import org
.eclipse
.linuxtools
.tmf
.ui
.views
.timechart
.TimeChartEvent
.RankRange
;
55 import org
.eclipse
.swt
.SWT
;
56 import org
.eclipse
.swt
.layout
.GridLayout
;
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
;
62 public class TimeChartView
extends TmfView
implements ITmfTimeScaleSelectionListener
, ITmfTimeSelectionListener
, IColorSettingsListener
,
63 IResourceChangeListener
, ITmfEventsFilterListener
{
65 public static final String ID
= "org.eclipse.linuxtools.tmf.ui.views.timechart"; //$NON-NLS-1$
67 private static final byte TIMESTAMP_SCALE
= -9;
69 private final int fDisplayWidth
;
70 private Composite fComposite
;
71 private ITimeAnalysisViewer fViewer
;
72 private final ArrayList
<TimeChartAnalysisEntry
> fTimeAnalysisEntries
= new ArrayList
<TimeChartAnalysisEntry
>();
73 private final Map
<ITmfTrace
<?
>, TimeChartDecorationProvider
> fDecorationProviders
= new HashMap
<ITmfTrace
<?
>, TimeChartDecorationProvider
>();
74 private ArrayList
<DecorateThread
> fDecorateThreads
;
75 private long fStartTime
= 0;
76 private long fStopTime
= Long
.MAX_VALUE
;
77 private boolean fRefreshBusy
= false;
78 private boolean fRefreshPending
= false;
79 private final Object fSyncObj
= new Object();
81 public TimeChartView() {
82 super("Time Chart"); //$NON-NLS-1$
83 fDisplayWidth
= Display
.getDefault().getBounds().width
;
87 public void createPartControl(Composite parent
) {
88 fComposite
= new Composite(parent
, SWT
.NONE
);
89 GridLayout gl
= new GridLayout();
92 fComposite
.setLayout(gl
);
94 fViewer
= TmfViewerFactory
.createViewer(fComposite
, new TimeChartAnalysisProvider());
95 fViewer
.groupTraces(false);
96 fViewer
.setTimeCalendarFormat(true);
97 fViewer
.setAcceptSelectionAPIcalls(true);
98 fViewer
.addWidgetTimeScaleSelectionListner(this);
99 fViewer
.addWidgetSelectionListner(this);
100 fViewer
.setMinimumItemWidth(1);
102 IEditorReference
[] editorReferences
= getSite().getPage().getEditorReferences();
103 for (IEditorReference editorReference
: editorReferences
) {
104 IEditorPart editor
= editorReference
.getEditor(false);
105 if (editor
instanceof ITmfTraceEditor
) {
106 ITmfTrace
<?
> trace
= ((ITmfTraceEditor
) editor
).getTrace();
108 IResource resource
= ((ITmfTraceEditor
) editor
).getResource();
109 TimeChartAnalysisEntry timeAnalysisEntry
= new TimeChartAnalysisEntry(trace
, fDisplayWidth
* 2);
110 fTimeAnalysisEntries
.add(timeAnalysisEntry
);
111 fDecorationProviders
.put(trace
, new TimeChartDecorationProvider(resource
));
112 Thread thread
= new ProcessTraceThread(timeAnalysisEntry
);
117 fViewer
.display(fTimeAnalysisEntries
.toArray(new TimeChartAnalysisEntry
[0]));
119 fDecorateThreads
= new ArrayList
<DecorateThread
>();
120 ColorSettingsManager
.addColorSettingsListener(this);
121 ResourcesPlugin
.getWorkspace().addResourceChangeListener(this, IResourceChangeEvent
.POST_CHANGE
);
125 public void dispose() {
126 ResourcesPlugin
.getWorkspace().removeResourceChangeListener(this);
127 for (DecorateThread thread
: fDecorateThreads
) {
130 ColorSettingsManager
.removeColorSettingsListener(this);
135 public void setFocus() {
140 private class ProcessTraceThread
extends Thread
{
142 private final TimeChartAnalysisEntry fTimeAnalysisEntry
;
144 public ProcessTraceThread(TimeChartAnalysisEntry timeAnalysisEntry
) {
145 super("ProcessTraceJob:" + timeAnalysisEntry
.getName()); //$NON-NLS-1$
146 fTimeAnalysisEntry
= timeAnalysisEntry
;
151 updateTraceEntry(fTimeAnalysisEntry
, Long
.MAX_VALUE
, 0, Long
.MAX_VALUE
);
155 private void updateTraceEntry(TimeChartAnalysisEntry timeAnalysisEntry
, long stopRank
, long startTime
, long stopTime
) {
156 ITmfTrace
<?
> trace
= timeAnalysisEntry
.getTrace();
157 TimeChartDecorationProvider decorationProvider
= fDecorationProviders
.get(trace
);
158 if (decorationProvider
== null) {
159 return; // the trace has been closed
161 TmfContext context
= null;
162 // TmfTimestamp lastTimestamp = null;
163 boolean done
= false;
165 synchronized (timeAnalysisEntry
) {
166 if (timeAnalysisEntry
.getLastRank() >= trace
.getNbEvents()) {
170 if (context
== null || context
.getRank() != timeAnalysisEntry
.getLastRank()) {
171 if (context
!= null) {
174 if (timeAnalysisEntry
.getLastRank() != -1) {
175 context
= trace
.seekEvent(timeAnalysisEntry
.getLastRank());
177 // context = trace.seekLocation(null);
178 context
= trace
.seekEvent(0);
182 long rank
= context
.getRank();
183 TmfEvent event
= trace
.getNextEvent(context
);
188 // if (!event.getTimestamp().equals(lastTimestamp)) {
189 TimeChartEvent timeEvent
= new TimeChartEvent(timeAnalysisEntry
, event
, rank
, decorationProvider
);
190 if (timeEvent
.getTime() >= startTime
&& timeEvent
.getTime() <= stopTime
) {
191 timeAnalysisEntry
.addTraceEvent(timeEvent
);
193 // lastTimestamp = event.getTimestamp();
194 // } *** commented out so that color setting priority gets
195 // set even if the event has same time
196 if (context
.getRank() == trace
.getNbEvents() || context
.getRank() == stopRank
) {
200 if (context
.getRank() % trace
.getCacheSize() == 1) {
201 // break for UI refresh
205 // timeAnalysisEntry.setLastRank(Math.min(trace.getNbEvents(),
207 timeAnalysisEntry
.setLastRank(context
.getRank());
209 refreshViewer(false);
211 if (context
!= null) {
216 private void refreshViewer(boolean resetTimeIntervals
) {
217 if (fComposite
== null) {
220 synchronized (fSyncObj
) {
222 fRefreshPending
= true;
228 final boolean reset
= resetTimeIntervals
;
229 // Perform the refresh on the UI thread
230 Display
.getDefault().asyncExec(new Runnable() {
233 if (fComposite
.isDisposed())
235 fViewer
.display(fTimeAnalysisEntries
.toArray(new TimeChartAnalysisEntry
[0]));
237 fViewer
.resetStartFinishTime();
239 synchronized (fSyncObj
) {
240 fRefreshBusy
= false;
241 if (fRefreshPending
) {
242 fRefreshPending
= false;
243 refreshViewer(reset
);
250 private void itemize(long startTime
, long stopTime
) {
251 for (int i
= 0; i
< fTimeAnalysisEntries
.size(); i
++) {
252 Thread thread
= new ItemizeThread(fTimeAnalysisEntries
.get(i
), startTime
, stopTime
);
257 private class ItemizeThread
extends Thread
{
259 private final TimeChartAnalysisEntry fTimeAnalysisEntry
;
260 private final long fStartTime
;
261 private final long fStopTime
;
262 private final long fMaxDuration
;
264 private ItemizeThread(TimeChartAnalysisEntry timeAnalysisEntry
, long startTime
, long stopTime
) {
265 super("Itemize Thread:" + timeAnalysisEntry
.getName()); //$NON-NLS-1$
266 fTimeAnalysisEntry
= timeAnalysisEntry
;
267 fStartTime
= startTime
;
268 fStopTime
= stopTime
;
269 fMaxDuration
= 3 * (fStopTime
- fStartTime
) / fDisplayWidth
;
274 itemizeTraceEntry(fTimeAnalysisEntry
);
277 public void itemizeTraceEntry(TimeChartAnalysisEntry timeAnalysisEntry
) {
278 Iterator
<ITimeEvent
> iterator
= timeAnalysisEntry
.getTraceEventsIterator();
279 TimeChartEvent event
= null;
280 boolean hasNext
= true;
282 synchronized (timeAnalysisEntry
) {
283 while (hasNext
= iterator
.hasNext()) {
284 event
= (TimeChartEvent
) iterator
.next();
285 if (event
.getTime() + event
.getDuration() > fStartTime
&& event
.getTime() < fStopTime
&& event
.getDuration() > fMaxDuration
286 && event
.getNbEvents() > 1) {
292 if (event
.getItemizedEntry() == null) {
295 itemizeTraceEntry(event
.getItemizedEntry());
301 public void itemizeEvent(TimeChartEvent event
) {
302 synchronized (event
) {
303 if (event
.isItemizing()) {
306 event
.setItemizing(true);
308 TimeChartAnalysisEntry timeAnalysisEntry
= new TimeChartAnalysisEntry(fTimeAnalysisEntry
.getTrace(), (int) Math
.min(
309 event
.getNbEvents() + 1, fDisplayWidth
* 2));
310 synchronized (event
.getRankRangeList()) {
311 for (RankRange range
: event
.getRankRangeList()) {
312 timeAnalysisEntry
.setLastRank(range
.getFirstRank());
313 updateTraceEntry(timeAnalysisEntry
, range
.getLastRank() + 1, event
.getTime(), event
.getTime() + event
.getDuration());
316 event
.setItemizedEntry(timeAnalysisEntry
);
317 refreshViewer(false);
318 itemizeTraceEntry(timeAnalysisEntry
);
319 synchronized (event
) {
320 event
.setItemizing(false);
325 private void redecorate() {
326 synchronized (fDecorateThreads
) {
327 for (DecorateThread thread
: fDecorateThreads
) {
330 fDecorateThreads
.clear();
331 for (int i
= 0; i
< fTimeAnalysisEntries
.size(); i
++) {
332 DecorateThread thread
= new DecorateThread(fTimeAnalysisEntries
.get(i
));
334 fDecorateThreads
.add(thread
);
339 private class DecorateThread
extends Thread
{
340 private volatile boolean interrupted
= false;
341 private final TimeChartAnalysisEntry fTimeAnalysisEntry
;
342 private final TimeChartDecorationProvider fDecorationProvider
;
343 private TmfContext fContext
;
344 private int fCount
= 0;
346 private DecorateThread(TimeChartAnalysisEntry timeAnalysisEntry
) {
347 super("Decorate Thread:" + timeAnalysisEntry
.getName()); //$NON-NLS-1$
348 fTimeAnalysisEntry
= timeAnalysisEntry
;
349 fDecorationProvider
= fDecorationProviders
.get(timeAnalysisEntry
.getTrace());
354 resetTraceEntry(fTimeAnalysisEntry
);
355 refreshViewer(false);
356 decorateTraceEntry(fTimeAnalysisEntry
, null);
357 refreshViewer(false);
358 synchronized (fDecorateThreads
) {
359 fDecorateThreads
.remove(this);
361 if (fContext
!= null) {
366 public void resetTraceEntry(TimeChartAnalysisEntry timeAnalysisEntry
) {
367 Iterator
<ITimeEvent
> iterator
= timeAnalysisEntry
.getTraceEventsIterator();
368 TimeChartEvent event
= null;
369 boolean hasNext
= true;
370 while (!interrupted
&& hasNext
) {
371 synchronized (timeAnalysisEntry
) {
372 while (hasNext
= iterator
.hasNext()) {
373 event
= (TimeChartEvent
) iterator
.next();
378 // TODO possible concurrency problem here with ItemizeJob
379 event
.setColorSettingPriority(ColorSettingsManager
.PRIORITY_NONE
);
380 if (event
.getItemizedEntry() != null) {
381 resetTraceEntry(event
.getItemizedEntry());
387 public void decorateTraceEntry(TimeChartAnalysisEntry timeAnalysisEntry
, TimeChartEvent parentEvent
) {
388 // Set max duration high to ensure iterator does not consider
390 Iterator
<ITimeEvent
> iterator
= timeAnalysisEntry
.getTraceEventsIterator(0, Long
.MAX_VALUE
, Long
.MAX_VALUE
);
391 TimeChartEvent event
= null;
392 int entryPriority
= ColorSettingsManager
.PRIORITY_NONE
;
393 boolean entryIsBookmarked
= false;
394 boolean entryIsVisible
= false;
395 boolean entryIsSearchMatch
= false;
396 boolean hasNext
= true;
397 while (!interrupted
&& hasNext
) {
398 synchronized (timeAnalysisEntry
) {
399 while (hasNext
= iterator
.hasNext()) {
400 event
= (TimeChartEvent
) iterator
.next();
405 // TODO possible concurrency problem here with ItemizeJob
406 if (event
.getItemizedEntry() == null) {
407 decorateEvent(event
);
409 decorateTraceEntry(event
.getItemizedEntry(), event
);
411 entryPriority
= Math
.min(entryPriority
, event
.getColorSettingPriority());
412 entryIsBookmarked
|= event
.isBookmarked();
413 entryIsVisible
|= event
.isVisible();
414 entryIsSearchMatch
|= event
.isSearchMatch();
415 if (++fCount
% timeAnalysisEntry
.getTrace().getCacheSize() == 0) {
416 refreshViewer(false);
420 if (parentEvent
!= null) {
421 parentEvent
.setColorSettingPriority(entryPriority
);
422 parentEvent
.setIsBookmarked(entryIsBookmarked
);
423 parentEvent
.setIsVisible(entryIsVisible
);
424 parentEvent
.setIsSearchMatch(entryIsSearchMatch
);
428 public void decorateEvent(TimeChartEvent timeChartEvent
) {
429 // TODO possible concurrency problem here with ItemizeJob
430 TimeChartAnalysisEntry timeAnalysisEntry
= (TimeChartAnalysisEntry
) timeChartEvent
.getEntry();
431 ITmfTrace
<?
> trace
= timeAnalysisEntry
.getTrace();
432 int priority
= ColorSettingsManager
.PRIORITY_NONE
;
433 boolean isBookmarked
= false;
434 boolean isVisible
= false;
435 boolean isSearchMatch
= false;
436 synchronized (timeChartEvent
.getRankRangeList()) {
437 for (RankRange range
: timeChartEvent
.getRankRangeList()) {
440 if (fContext
== null || fContext
.getRank() != range
.getFirstRank()) {
441 if (fContext
!= null) {
444 fContext
= trace
.seekEvent(range
.getFirstRank());
445 fContext
.setRank(range
.getFirstRank());
450 long rank
= fContext
.getRank();
451 TmfEvent event
= trace
.getNextEvent(fContext
);
455 long eventTime
= event
.getTimestamp().synchronize(0, (byte) -9).getValue();
456 if (eventTime
>= timeChartEvent
.getTime() && eventTime
<= timeChartEvent
.getTime() + timeChartEvent
.getDuration()) {
457 priority
= Math
.min(priority
, ColorSettingsManager
.getColorSettingPriority(event
));
459 isBookmarked
|= fDecorationProvider
.isBookmark(rank
);
460 isVisible
|= fDecorationProvider
.isVisible(event
);
461 isSearchMatch
|= fDecorationProvider
.isSearchMatch(event
);
462 if (fContext
.getRank() > range
.getLastRank()) {
468 timeChartEvent
.setColorSettingPriority(priority
);
469 timeChartEvent
.setIsBookmarked(isBookmarked
);
470 timeChartEvent
.setIsVisible(isVisible
);
471 timeChartEvent
.setIsSearchMatch(isSearchMatch
);
474 public void cancel() {
479 // ------------------------------------------------------------------------
481 // ------------------------------------------------------------------------
484 public void tsfTmProcessTimeScaleEvent(TmfTimeScaleSelectionEvent event
) {
485 fStartTime
= event
.getTime0();
486 fStopTime
= event
.getTime1();
487 itemize(fStartTime
, fStopTime
);
491 public void tsfTmProcessSelEvent(TmfTimeSelectionEvent event
) {
492 ITmfTimeAnalysisEntry timeAnalysisEntry
= null;
493 if (event
.getSelection() instanceof TimeChartAnalysisEntry
) {
494 timeAnalysisEntry
= (TimeChartAnalysisEntry
) event
.getSelection();
495 } else if (event
.getSelection() instanceof TimeChartEvent
) {
496 timeAnalysisEntry
= ((TimeChartEvent
) event
.getSelection()).getEntry();
498 if (timeAnalysisEntry
instanceof TimeChartAnalysisEntry
) {
499 broadcast(new TmfTraceSelectedSignal(this, ((TimeChartAnalysisEntry
) timeAnalysisEntry
).getTrace()));
501 broadcast(new TmfTimeSynchSignal(this, new TmfTimestamp(event
.getSelectedTime(), TIMESTAMP_SCALE
)));
505 public void colorSettingsChanged(ColorSetting
[] colorSettings
) {
510 public void resourceChanged(IResourceChangeEvent event
) {
511 for (IMarkerDelta delta
: event
.findMarkerDeltas(IMarker
.BOOKMARK
, false)) {
512 for (TimeChartDecorationProvider provider
: fDecorationProviders
.values()) {
513 if (delta
.getResource().equals(provider
.getResource())) {
514 if (delta
.getKind() == IResourceDelta
.CHANGED
&& delta
.getMarker().getAttribute(IMarker
.LOCATION
, -1) != -1) {
515 provider
.refreshBookmarks();
516 } else if (delta
.getKind() == IResourceDelta
.REMOVED
) {
517 provider
.refreshBookmarks();
526 public void filterApplied(ITmfFilter filter
, ITmfTrace
<?
> trace
) {
527 TimeChartDecorationProvider decorationProvider
= fDecorationProviders
.get(trace
);
528 decorationProvider
.filterApplied(filter
);
533 public void searchApplied(ITmfFilter filter
, ITmfTrace
<?
> trace
) {
534 TimeChartDecorationProvider decorationProvider
= fDecorationProviders
.get(trace
);
535 decorationProvider
.searchApplied(filter
);
539 // ------------------------------------------------------------------------
541 // ------------------------------------------------------------------------
544 public void traceOpened(TmfTraceOpenedSignal signal
) {
545 if (fTimeAnalysisEntries
== null)
547 final ITmfTrace
<?
> trace
= signal
.getTrace();
548 if (trace
instanceof TmfExperiment
) {
551 final IResource resource
= signal
.getResource();
552 final ITmfEventsFilterProvider eventsFilterProvider
= signal
.getEventsFilterProvider();
553 TimeChartAnalysisEntry timeAnalysisEntry
= null;
554 for (int i
= 0; i
< fTimeAnalysisEntries
.size(); i
++) {
555 if (fTimeAnalysisEntries
.get(i
).getTrace().equals(trace
)) {
556 timeAnalysisEntry
= fTimeAnalysisEntries
.get(i
);
560 if (timeAnalysisEntry
== null) {
561 timeAnalysisEntry
= new TimeChartAnalysisEntry(trace
, fDisplayWidth
* 2);
562 fTimeAnalysisEntries
.add(timeAnalysisEntry
);
563 fDecorationProviders
.put(trace
, new TimeChartDecorationProvider(resource
));
564 Thread thread
= new ProcessTraceThread(timeAnalysisEntry
);
568 if (eventsFilterProvider
!= null) {
569 eventsFilterProvider
.addEventsFilterListener(this);
574 public void traceClosed(TmfTraceClosedSignal signal
) {
575 if (fTimeAnalysisEntries
== null)
577 final ITmfTrace
<?
> trace
= signal
.getTrace();
578 for (int i
= 0; i
< fTimeAnalysisEntries
.size(); i
++) {
579 if (fTimeAnalysisEntries
.get(i
).getTrace().equals(trace
)) {
580 fTimeAnalysisEntries
.remove(i
);
581 fDecorationProviders
.remove(trace
);
589 public void traceSelected(TmfTraceSelectedSignal signal
) {
590 if (signal
.getSource() != this && fTimeAnalysisEntries
!= null) {
591 ITmfTrace
<?
> trace
= signal
.getTrace();
592 for (int i
= 0; i
< fTimeAnalysisEntries
.size(); i
++) {
593 if (fTimeAnalysisEntries
.get(i
).getTrace().equals(trace
)) {
594 fViewer
.setSelectedTrace(fTimeAnalysisEntries
.get(i
));
602 public void traceUpdated(TmfTraceUpdatedSignal signal
) {
603 if (fTimeAnalysisEntries
== null)
605 final ITmfTrace
<?
> trace
= signal
.getTrace();
606 for (int i
= 0; i
< fTimeAnalysisEntries
.size(); i
++) {
607 TimeChartAnalysisEntry timeAnalysisEntry
= fTimeAnalysisEntries
.get(i
);
608 if (timeAnalysisEntry
.getTrace().equals(trace
)) {
609 updateTraceEntry(timeAnalysisEntry
, Long
.MAX_VALUE
, 0, Long
.MAX_VALUE
);
616 public void currentTimeUpdated(TmfTimeSynchSignal signal
) {
617 long time
= signal
.getCurrentTime().synchronize(0, TIMESTAMP_SCALE
).getValue();
618 fViewer
.setSelectedTime(time
, true, this);