1 /*******************************************************************************
2 * Copyright (c) 2010, 2016 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
;
18 import java
.util
.List
;
21 import org
.eclipse
.core
.resources
.IFile
;
22 import org
.eclipse
.core
.resources
.IMarker
;
23 import org
.eclipse
.core
.resources
.IMarkerDelta
;
24 import org
.eclipse
.core
.resources
.IResourceChangeEvent
;
25 import org
.eclipse
.core
.resources
.IResourceChangeListener
;
26 import org
.eclipse
.core
.resources
.IResourceDelta
;
27 import org
.eclipse
.core
.resources
.ResourcesPlugin
;
28 import org
.eclipse
.jface
.action
.IStatusLineManager
;
29 import org
.eclipse
.swt
.SWT
;
30 import org
.eclipse
.swt
.widgets
.Composite
;
31 import org
.eclipse
.swt
.widgets
.Display
;
32 import org
.eclipse
.tracecompass
.tmf
.core
.event
.ITmfEvent
;
33 import org
.eclipse
.tracecompass
.tmf
.core
.resources
.ITmfMarker
;
34 import org
.eclipse
.tracecompass
.tmf
.core
.signal
.TmfEventFilterAppliedSignal
;
35 import org
.eclipse
.tracecompass
.tmf
.core
.signal
.TmfEventSearchAppliedSignal
;
36 import org
.eclipse
.tracecompass
.tmf
.core
.signal
.TmfSelectionRangeUpdatedSignal
;
37 import org
.eclipse
.tracecompass
.tmf
.core
.signal
.TmfSignalHandler
;
38 import org
.eclipse
.tracecompass
.tmf
.core
.signal
.TmfTraceClosedSignal
;
39 import org
.eclipse
.tracecompass
.tmf
.core
.signal
.TmfTraceOpenedSignal
;
40 import org
.eclipse
.tracecompass
.tmf
.core
.signal
.TmfTraceSelectedSignal
;
41 import org
.eclipse
.tracecompass
.tmf
.core
.signal
.TmfTraceUpdatedSignal
;
42 import org
.eclipse
.tracecompass
.tmf
.core
.signal
.TmfWindowRangeUpdatedSignal
;
43 import org
.eclipse
.tracecompass
.tmf
.core
.timestamp
.ITmfTimestamp
;
44 import org
.eclipse
.tracecompass
.tmf
.core
.timestamp
.TmfTimeRange
;
45 import org
.eclipse
.tracecompass
.tmf
.core
.timestamp
.TmfTimestamp
;
46 import org
.eclipse
.tracecompass
.tmf
.core
.trace
.ITmfContext
;
47 import org
.eclipse
.tracecompass
.tmf
.core
.trace
.ITmfTrace
;
48 import org
.eclipse
.tracecompass
.tmf
.core
.trace
.TmfTraceContext
;
49 import org
.eclipse
.tracecompass
.tmf
.core
.trace
.TmfTraceManager
;
50 import org
.eclipse
.tracecompass
.tmf
.ui
.signal
.TmfTimeViewAlignmentInfo
;
51 import org
.eclipse
.tracecompass
.tmf
.ui
.views
.ITmfTimeAligned
;
52 import org
.eclipse
.tracecompass
.tmf
.ui
.views
.TmfView
;
53 import org
.eclipse
.tracecompass
.tmf
.ui
.views
.colors
.ColorSetting
;
54 import org
.eclipse
.tracecompass
.tmf
.ui
.views
.colors
.ColorSettingsManager
;
55 import org
.eclipse
.tracecompass
.tmf
.ui
.views
.colors
.IColorSettingsListener
;
56 import org
.eclipse
.tracecompass
.tmf
.ui
.views
.timechart
.TimeChartEvent
.RankRange
;
57 import org
.eclipse
.tracecompass
.tmf
.ui
.widgets
.timegraph
.ITimeGraphPresentationProvider
;
58 import org
.eclipse
.tracecompass
.tmf
.ui
.widgets
.timegraph
.ITimeGraphRangeListener
;
59 import org
.eclipse
.tracecompass
.tmf
.ui
.widgets
.timegraph
.ITimeGraphSelectionListener
;
60 import org
.eclipse
.tracecompass
.tmf
.ui
.widgets
.timegraph
.ITimeGraphTimeListener
;
61 import org
.eclipse
.tracecompass
.tmf
.ui
.widgets
.timegraph
.TimeGraphRangeUpdateEvent
;
62 import org
.eclipse
.tracecompass
.tmf
.ui
.widgets
.timegraph
.TimeGraphSelectionEvent
;
63 import org
.eclipse
.tracecompass
.tmf
.ui
.widgets
.timegraph
.TimeGraphTimeEvent
;
64 import org
.eclipse
.tracecompass
.tmf
.ui
.widgets
.timegraph
.TimeGraphViewer
;
65 import org
.eclipse
.tracecompass
.tmf
.ui
.widgets
.timegraph
.model
.ITimeEvent
;
66 import org
.eclipse
.tracecompass
.tmf
.ui
.widgets
.timegraph
.model
.ITimeGraphEntry
;
67 import org
.eclipse
.tracecompass
.tmf
.ui
.widgets
.timegraph
.widgets
.Utils
.TimeFormat
;
70 * Generic Time Chart view, which is similar to a Gantt chart for trace analysis
73 * @author Patrick Tasse
75 public class TimeChartView
extends TmfView
implements ITimeGraphRangeListener
, ITimeGraphSelectionListener
, ITimeGraphTimeListener
, IColorSettingsListener
, IResourceChangeListener
, ITmfTimeAligned
{
77 /** TimeChartView's ID */
78 public static final String ID
= "org.eclipse.linuxtools.tmf.ui.views.timechart"; //$NON-NLS-1$
80 private final int fDisplayWidth
;
81 private TimeGraphViewer fViewer
;
82 private final List
<TimeChartAnalysisEntry
> fTimeAnalysisEntries
= new ArrayList
<>();
83 private final Map
<ITmfTrace
, TimeChartDecorationProvider
> fDecorationProviders
= new HashMap
<>();
84 private final List
<DecorateThread
> fDecorateThreads
= new ArrayList
<>();
85 private final Map
<ITmfTrace
, ProcessTraceThread
> fProcessTraceThreads
= new HashMap
<>();
86 private long fStartTime
= 0;
87 private long fStopTime
= Long
.MAX_VALUE
;
88 private boolean fRefreshBusy
= false;
89 private boolean fRefreshPending
= false;
90 private boolean fRedrawBusy
= false;
91 private boolean fRedrawPending
= false;
92 private final Object fSyncObj
= new Object();
93 private ITimeGraphPresentationProvider fPresentationProvider
;
98 public TimeChartView() {
99 super("Time Chart"); //$NON-NLS-1$
100 fDisplayWidth
= Display
.getDefault().getBounds().width
;
104 public void createPartControl(Composite parent
) {
105 super.createPartControl(parent
);
106 fViewer
= new TimeGraphViewer(parent
, SWT
.NONE
);
107 fPresentationProvider
= new TimeChartAnalysisProvider();
108 fViewer
.setTimeGraphProvider(fPresentationProvider
);
109 fViewer
.setTimeFormat(TimeFormat
.CALENDAR
);
110 fViewer
.addTimeListener(this);
111 fViewer
.addRangeListener(this);
112 fViewer
.addSelectionListener(this);
113 fViewer
.setMinimumItemWidth(1);
114 fViewer
.getTimeGraphControl().setBlendSubPixelEvents(true);
116 IStatusLineManager statusLineManager
= getViewSite().getActionBars().getStatusLineManager();
117 fViewer
.getTimeGraphControl().setStatusLineManager(statusLineManager
);
119 for (ITmfTrace trace
: TmfTraceManager
.getInstance().getOpenedTraces()) {
120 IFile bookmarksFile
= TmfTraceManager
.getInstance().getTraceEditorFile(trace
);
121 TimeChartAnalysisEntry timeAnalysisEntry
= new TimeChartAnalysisEntry(trace
, fDisplayWidth
* 2);
122 fTimeAnalysisEntries
.add(timeAnalysisEntry
);
123 fDecorationProviders
.put(trace
, new TimeChartDecorationProvider(bookmarksFile
));
124 startProcessTraceThread(timeAnalysisEntry
);
126 fViewer
.setInput(fTimeAnalysisEntries
.toArray(new TimeChartAnalysisEntry
[0]));
128 ColorSettingsManager
.addColorSettingsListener(this);
129 ResourcesPlugin
.getWorkspace().addResourceChangeListener(this, IResourceChangeEvent
.POST_CHANGE
);
133 public void dispose() {
134 ResourcesPlugin
.getWorkspace().removeResourceChangeListener(this);
135 synchronized (fDecorateThreads
) {
136 for (DecorateThread thread
: fDecorateThreads
) {
140 ColorSettingsManager
.removeColorSettingsListener(this);
145 public void setFocus() {
149 private void startProcessTraceThread(TimeChartAnalysisEntry entry
) {
150 synchronized (fProcessTraceThreads
) {
151 ProcessTraceThread thread
= fProcessTraceThreads
.get(entry
.getTrace());
152 if (thread
!= null) {
155 thread
= new ProcessTraceThread(entry
);
156 fProcessTraceThreads
.put(entry
.getTrace(), thread
);
162 private class ProcessTraceThread
extends Thread
{
164 private final TimeChartAnalysisEntry fTimeAnalysisEntry
;
165 private boolean fRestart
;
167 public ProcessTraceThread(TimeChartAnalysisEntry timeAnalysisEntry
) {
168 super("ProcessTraceJob:" + timeAnalysisEntry
.getName()); //$NON-NLS-1$
169 fTimeAnalysisEntry
= timeAnalysisEntry
;
172 public void restart() {
173 synchronized (fProcessTraceThreads
) {
181 updateTraceEntry(fTimeAnalysisEntry
, Long
.MAX_VALUE
,
182 TmfTimestamp
.BIG_BANG
.toNanos(),
183 TmfTimestamp
.BIG_CRUNCH
.toNanos());
184 synchronized (fProcessTraceThreads
) {
188 fProcessTraceThreads
.remove(fTimeAnalysisEntry
.getTrace());
196 private void updateTraceEntry(TimeChartAnalysisEntry timeAnalysisEntry
, long stopRank
, long startTime
, long stopTime
) {
197 ITmfTrace trace
= timeAnalysisEntry
.getTrace();
198 TimeChartDecorationProvider decorationProvider
= fDecorationProviders
.get(trace
);
199 if (decorationProvider
== null) {
200 return; // the trace has been closed
202 ITmfContext context
= null;
203 // TmfTimestamp lastTimestamp = null;
204 boolean done
= false;
206 synchronized (timeAnalysisEntry
) {
207 if (timeAnalysisEntry
.getLastRank() >= trace
.getNbEvents()) {
211 if (context
== null || context
.getRank() != timeAnalysisEntry
.getLastRank()) {
212 if (context
!= null) {
215 if (timeAnalysisEntry
.getLastRank() != -1) {
216 context
= trace
.seekEvent(timeAnalysisEntry
.getLastRank());
218 // context = trace.seekLocation(null);
219 context
= trace
.seekEvent(0);
223 long rank
= context
.getRank();
224 ITmfEvent event
= trace
.getNext(context
);
229 // if (!event.getTimestamp().equals(lastTimestamp)) {
230 TimeChartEvent timeEvent
= new TimeChartEvent(timeAnalysisEntry
, event
, rank
, decorationProvider
);
231 if (timeEvent
.getTime() >= startTime
&& timeEvent
.getTime() <= stopTime
) {
232 timeAnalysisEntry
.addTraceEvent(timeEvent
);
234 // lastTimestamp = event.getTimestamp();
235 // } *** commented out so that color setting priority gets
236 // set even if the event has same time
237 if (context
.getRank() == trace
.getNbEvents() || context
.getRank() == stopRank
) {
241 if (context
.getRank() % trace
.getCacheSize() == 1) {
242 // break for UI refresh
246 // timeAnalysisEntry.setLastRank(Math.min(trace.getNbEvents(),
248 timeAnalysisEntry
.setLastRank(context
.getRank());
252 if (context
!= null) {
257 private void refreshViewer() {
258 synchronized (fSyncObj
) {
260 fRefreshPending
= true;
265 // Perform the refresh on the UI thread
266 Display
.getDefault().asyncExec(new Runnable() {
269 if (fViewer
.getControl().isDisposed()) {
272 fViewer
.setInput(fTimeAnalysisEntries
.toArray(new TimeChartAnalysisEntry
[0]));
273 fViewer
.resetStartFinishTime(false);
274 synchronized (fSyncObj
) {
275 fRefreshBusy
= false;
276 if (fRefreshPending
) {
277 fRefreshPending
= false;
285 private void redrawViewer(boolean resetTimeIntervals
) {
286 synchronized (fSyncObj
) {
288 fRedrawPending
= true;
293 final boolean reset
= resetTimeIntervals
;
294 // Perform the refresh on the UI thread
295 Display
.getDefault().asyncExec(new Runnable() {
298 if (fViewer
.getControl().isDisposed()) {
302 fViewer
.setTimeRange(fTimeAnalysisEntries
.toArray(new TimeChartAnalysisEntry
[0]));
303 fViewer
.setTimeBounds();
305 fViewer
.getControl().redraw();
306 fViewer
.getControl().update();
307 synchronized (fSyncObj
) {
309 if (fRedrawPending
) {
310 fRedrawPending
= false;
318 private void itemize(long startTime
, long stopTime
) {
319 for (int i
= 0; i
< fTimeAnalysisEntries
.size(); i
++) {
320 Thread thread
= new ItemizeThread(fTimeAnalysisEntries
.get(i
), startTime
, stopTime
);
325 private class ItemizeThread
extends Thread
{
327 private final TimeChartAnalysisEntry fTimeAnalysisEntry
;
328 private final long startTime
;
329 private final long stopTime
;
330 private final long fMaxDuration
;
332 private ItemizeThread(TimeChartAnalysisEntry timeAnalysisEntry
, long startTime
, long stopTime
) {
333 super("Itemize Thread:" + timeAnalysisEntry
.getName()); //$NON-NLS-1$
334 fTimeAnalysisEntry
= timeAnalysisEntry
;
335 this.startTime
= startTime
;
336 this.stopTime
= stopTime
;
337 fMaxDuration
= 3 * (stopTime
- startTime
) / fDisplayWidth
;
342 itemizeTraceEntry(fTimeAnalysisEntry
);
345 public void itemizeTraceEntry(TimeChartAnalysisEntry timeAnalysisEntry
) {
346 Iterator
<ITimeEvent
> iterator
= timeAnalysisEntry
.getTimeEventsIterator();
347 TimeChartEvent event
= null;
348 boolean hasNext
= true;
350 synchronized (timeAnalysisEntry
) {
351 while ((hasNext
= iterator
.hasNext()) == true) {
352 event
= (TimeChartEvent
) iterator
.next();
353 if (event
.getTime() + event
.getDuration() > startTime
&& event
.getTime() < stopTime
&& event
.getDuration() > fMaxDuration
354 && event
.getNbEvents() > 1) {
359 if (hasNext
&& event
!= null) {
360 if (event
.getItemizedEntry() == null) {
363 itemizeTraceEntry(event
.getItemizedEntry());
369 public void itemizeEvent(TimeChartEvent event
) {
370 synchronized (event
) {
371 if (event
.isItemizing()) {
374 event
.setItemizing(true);
376 TimeChartAnalysisEntry timeAnalysisEntry
= new TimeChartAnalysisEntry(fTimeAnalysisEntry
.getTrace(), (int) Math
.min(
377 event
.getNbEvents() + 1, fDisplayWidth
* 2));
378 synchronized (event
.getRankRangeList()) {
379 for (RankRange range
: event
.getRankRangeList()) {
380 timeAnalysisEntry
.setLastRank(range
.getFirstRank());
381 updateTraceEntry(timeAnalysisEntry
, range
.getLastRank() + 1, event
.getTime(), event
.getTime() + event
.getDuration());
384 event
.setItemizedEntry(timeAnalysisEntry
);
386 itemizeTraceEntry(timeAnalysisEntry
);
387 synchronized (event
) {
388 event
.setItemizing(false);
393 private void redecorate() {
394 synchronized (fDecorateThreads
) {
395 for (DecorateThread thread
: fDecorateThreads
) {
398 fDecorateThreads
.clear();
399 for (int i
= 0; i
< fTimeAnalysisEntries
.size(); i
++) {
400 DecorateThread thread
= new DecorateThread(fTimeAnalysisEntries
.get(i
));
402 fDecorateThreads
.add(thread
);
407 private class DecorateThread
extends Thread
{
408 private volatile boolean interrupted
= false;
409 private final TimeChartAnalysisEntry fTimeAnalysisEntry
;
410 private final TimeChartDecorationProvider fDecorationProvider
;
411 private ITmfContext fContext
;
412 private int fCount
= 0;
414 private DecorateThread(TimeChartAnalysisEntry timeAnalysisEntry
) {
415 super("Decorate Thread:" + timeAnalysisEntry
.getName()); //$NON-NLS-1$
416 fTimeAnalysisEntry
= timeAnalysisEntry
;
417 fDecorationProvider
= fDecorationProviders
.get(timeAnalysisEntry
.getTrace());
422 resetTraceEntry(fTimeAnalysisEntry
);
424 decorateTraceEntry(fTimeAnalysisEntry
, null);
426 synchronized (fDecorateThreads
) {
427 fDecorateThreads
.remove(this);
429 if (fContext
!= null) {
434 public void resetTraceEntry(TimeChartAnalysisEntry timeAnalysisEntry
) {
435 Iterator
<ITimeEvent
> iterator
= timeAnalysisEntry
.getTimeEventsIterator();
436 TimeChartEvent event
= null;
437 boolean hasNext
= true;
438 while (!interrupted
&& hasNext
) {
439 synchronized (timeAnalysisEntry
) {
440 while ((hasNext
= iterator
.hasNext()) == true) {
441 event
= (TimeChartEvent
) iterator
.next();
445 if (hasNext
&& event
!= null) {
446 // TODO possible concurrency problem here with ItemizeJob
447 event
.setColorSettingPriority(ColorSettingsManager
.PRIORITY_NONE
);
448 if (event
.getItemizedEntry() != null) {
449 resetTraceEntry(event
.getItemizedEntry());
455 public void decorateTraceEntry(TimeChartAnalysisEntry timeAnalysisEntry
, TimeChartEvent parentEvent
) {
456 // Set max duration high to ensure iterator does not consider
458 Iterator
<ITimeEvent
> iterator
= timeAnalysisEntry
.getTimeEventsIterator(0, Long
.MAX_VALUE
, Long
.MAX_VALUE
);
459 TimeChartEvent event
= null;
460 int entryPriority
= ColorSettingsManager
.PRIORITY_NONE
;
461 boolean entryIsBookmarked
= false;
462 boolean entryIsVisible
= false;
463 boolean entryIsSearchMatch
= false;
464 boolean hasNext
= true;
465 while (!interrupted
&& hasNext
) {
466 synchronized (timeAnalysisEntry
) {
467 while ((hasNext
= iterator
.hasNext()) == true) {
468 event
= (TimeChartEvent
) iterator
.next();
472 if (hasNext
&& event
!= null) {
473 // TODO possible concurrency problem here with ItemizeJob
474 if (event
.getItemizedEntry() == null) {
475 decorateEvent(event
);
477 decorateTraceEntry(event
.getItemizedEntry(), event
);
479 entryPriority
= Math
.min(entryPriority
, event
.getColorSettingPriority());
480 entryIsBookmarked
|= event
.isBookmarked();
481 entryIsVisible
|= event
.isVisible();
482 entryIsSearchMatch
|= event
.isSearchMatch();
483 if (++fCount
% timeAnalysisEntry
.getTrace().getCacheSize() == 0) {
488 if (parentEvent
!= null) {
489 parentEvent
.setColorSettingPriority(entryPriority
);
490 parentEvent
.setIsBookmarked(entryIsBookmarked
);
491 parentEvent
.setIsVisible(entryIsVisible
);
492 parentEvent
.setIsSearchMatch(entryIsSearchMatch
);
496 public void decorateEvent(TimeChartEvent timeChartEvent
) {
497 // TODO possible concurrency problem here with ItemizeJob
498 TimeChartAnalysisEntry timeAnalysisEntry
= (TimeChartAnalysisEntry
) timeChartEvent
.getEntry();
499 ITmfTrace trace
= timeAnalysisEntry
.getTrace();
500 int priority
= ColorSettingsManager
.PRIORITY_NONE
;
501 boolean isBookmarked
= false;
502 boolean isVisible
= false;
503 boolean isSearchMatch
= false;
504 synchronized (timeChartEvent
.getRankRangeList()) {
505 for (RankRange range
: timeChartEvent
.getRankRangeList()) {
509 if (fContext
== null || fContext
.getRank() != range
.getFirstRank()) {
510 if (fContext
!= null) {
513 fContext
= trace
.seekEvent(range
.getFirstRank());
514 fContext
.setRank(range
.getFirstRank());
520 long rank
= fContext
.getRank();
521 ITmfEvent event
= trace
.getNext(fContext
);
525 long eventTime
= event
.getTimestamp().toNanos();
526 if (eventTime
>= timeChartEvent
.getTime() && eventTime
<= timeChartEvent
.getTime() + timeChartEvent
.getDuration()) {
527 priority
= Math
.min(priority
, ColorSettingsManager
.getColorSettingPriority(event
));
529 isBookmarked
|= fDecorationProvider
.isBookmark(rank
);
530 isVisible
|= fDecorationProvider
.isVisible(event
);
531 isSearchMatch
|= fDecorationProvider
.isSearchMatch(event
);
532 if (fContext
.getRank() > range
.getLastRank()) {
538 timeChartEvent
.setColorSettingPriority(priority
);
539 timeChartEvent
.setIsBookmarked(isBookmarked
);
540 timeChartEvent
.setIsVisible(isVisible
);
541 timeChartEvent
.setIsSearchMatch(isSearchMatch
);
544 public void cancel() {
549 // ------------------------------------------------------------------------
551 // ------------------------------------------------------------------------
554 public void timeRangeUpdated(TimeGraphRangeUpdateEvent event
) {
555 fStartTime
= event
.getStartTime();
556 fStopTime
= event
.getEndTime();
557 itemize(fStartTime
, fStopTime
);
558 final ITmfTimestamp startTimestamp
= TmfTimestamp
.fromNanos(event
.getStartTime());
559 final ITmfTimestamp endTimestamp
= TmfTimestamp
.fromNanos(event
.getEndTime());
560 TmfTimeRange range
= new TmfTimeRange(startTimestamp
, endTimestamp
);
561 broadcast(new TmfWindowRangeUpdatedSignal(this, range
));
565 public void selectionChanged(TimeGraphSelectionEvent event
) {
566 ITimeGraphEntry timeAnalysisEntry
= null;
567 if (event
.getSelection() instanceof TimeChartAnalysisEntry
) {
568 timeAnalysisEntry
= event
.getSelection();
569 } else if (event
.getSelection() instanceof TimeChartEvent
) {
570 timeAnalysisEntry
= ((TimeChartEvent
) event
.getSelection()).getEntry();
572 if (timeAnalysisEntry
instanceof TimeChartAnalysisEntry
) {
573 broadcast(new TmfTraceSelectedSignal(this, ((TimeChartAnalysisEntry
) timeAnalysisEntry
).getTrace()));
578 public void timeSelected(TimeGraphTimeEvent event
) {
579 broadcast(new TmfSelectionRangeUpdatedSignal(this, TmfTimestamp
.fromNanos(event
.getBeginTime()), TmfTimestamp
.fromNanos(event
.getEndTime())));
583 public void colorSettingsChanged(ColorSetting
[] colorSettings
) {
584 // Set presentation provider again to trigger re-creation of new color
585 // settings which are stored in the TimeGraphControl class
586 fViewer
.setTimeGraphProvider(fPresentationProvider
);
591 public void resourceChanged(IResourceChangeEvent event
) {
592 for (IMarkerDelta delta
: event
.findMarkerDeltas(IMarker
.BOOKMARK
, false)) {
593 for (TimeChartDecorationProvider provider
: fDecorationProviders
.values()) {
594 if (delta
.getResource().equals(provider
.getBookmarksFile())) {
595 if (delta
.getKind() == IResourceDelta
.REMOVED
||
596 delta
.getMarker().getAttribute(IMarker
.LOCATION
, -1) != -1 ||
597 delta
.getMarker().getAttribute(ITmfMarker
.MARKER_RANK
, (String
) null) != null) {
598 provider
.refreshBookmarks();
606 // ------------------------------------------------------------------------
608 // ------------------------------------------------------------------------
611 * Handler for the Trace Opened signal
614 * The incoming signal
617 public void traceOpened(TmfTraceOpenedSignal signal
) {
618 final ITmfTrace trace
= signal
.getTrace();
619 final IFile bookmarksFile
= signal
.getEditorFile();
620 TimeChartAnalysisEntry timeAnalysisEntry
= null;
621 for (int i
= 0; i
< fTimeAnalysisEntries
.size(); i
++) {
622 if (fTimeAnalysisEntries
.get(i
).getTrace().equals(trace
)) {
623 timeAnalysisEntry
= fTimeAnalysisEntries
.get(i
);
627 if (timeAnalysisEntry
== null) {
628 timeAnalysisEntry
= new TimeChartAnalysisEntry(trace
, fDisplayWidth
* 2);
629 fTimeAnalysisEntries
.add(timeAnalysisEntry
);
630 fDecorationProviders
.put(trace
, new TimeChartDecorationProvider(bookmarksFile
));
631 startProcessTraceThread(timeAnalysisEntry
);
637 * Handler for the Trace Closed signal
640 * The incoming signal
643 public void traceClosed(TmfTraceClosedSignal signal
) {
644 final ITmfTrace trace
= signal
.getTrace();
645 for (int i
= 0; i
< fTimeAnalysisEntries
.size(); i
++) {
646 if (fTimeAnalysisEntries
.get(i
).getTrace().equals(trace
)) {
647 fTimeAnalysisEntries
.remove(i
);
648 fDecorationProviders
.remove(trace
);
649 synchronized (fDecorateThreads
) {
650 for (DecorateThread thread
: fDecorateThreads
) {
651 if (thread
.fTimeAnalysisEntry
.getTrace() == trace
) {
653 fDecorateThreads
.remove(thread
);
665 * Handler for the Trace Selected signal
668 * The incoming signal
671 public void traceSelected(TmfTraceSelectedSignal signal
) {
672 if (signal
.getSource() != this) {
673 ITmfTrace trace
= signal
.getTrace();
674 for (int i
= 0; i
< fTimeAnalysisEntries
.size(); i
++) {
675 if (fTimeAnalysisEntries
.get(i
).getTrace().equals(trace
)) {
676 fViewer
.setSelection(fTimeAnalysisEntries
.get(i
));
680 TmfTraceContext ctx
= TmfTraceManager
.getInstance().getCurrentTraceContext();
681 long beginTime
= ctx
.getSelectionRange().getStartTime().toNanos();
682 long endTime
= ctx
.getSelectionRange().getEndTime().toNanos();
683 fViewer
.setSelectionRange(beginTime
, endTime
, false);
688 * Handler for the Trace Updated signal
691 * The incoming signal
694 public void traceUpdated(TmfTraceUpdatedSignal signal
) {
695 final ITmfTrace trace
= signal
.getTrace();
696 for (int i
= 0; i
< fTimeAnalysisEntries
.size(); i
++) {
697 TimeChartAnalysisEntry timeAnalysisEntry
= fTimeAnalysisEntries
.get(i
);
698 if (timeAnalysisEntry
.getTrace().equals(trace
)) {
699 startProcessTraceThread(timeAnalysisEntry
);
706 * Handler for the selection range updated signal.
709 * The incoming signal
713 public void selectionRangeUpdated(TmfSelectionRangeUpdatedSignal signal
) {
714 final long beginTime
= signal
.getBeginTime().toNanos();
715 final long endTime
= signal
.getEndTime().toNanos();
717 Display
.getDefault().asyncExec(new Runnable() {
720 if (beginTime
== endTime
) {
721 fViewer
.setSelectedTime(beginTime
, true);
722 if (fStartTime
!= fViewer
.getTime0() || fStopTime
!= fViewer
.getTime1()) {
723 fStartTime
= fViewer
.getTime0();
724 fStopTime
= fViewer
.getTime1();
725 itemize(fStartTime
, fStopTime
);
728 fViewer
.setSelectionRange(beginTime
, endTime
, true);
735 * Handler for the window range updated signal.
738 * The incoming signal
742 public void windowRangeUpdated(final TmfWindowRangeUpdatedSignal signal
) {
743 if (signal
.getSource() == this) {
746 final long startTime
= signal
.getCurrentRange().getStartTime().toNanos();
747 final long endTime
= signal
.getCurrentRange().getEndTime().toNanos();
748 Display
.getDefault().asyncExec(new Runnable() {
751 fStartTime
= startTime
;
753 itemize(fStartTime
, fStopTime
);
754 fViewer
.setStartFinishTime(startTime
, endTime
);
760 * Handler for the Event Filter Applied signal
763 * The incoming signal
766 public void filterApplied(TmfEventFilterAppliedSignal signal
) {
767 TimeChartDecorationProvider decorationProvider
= fDecorationProviders
.get(signal
.getTrace());
768 if (decorationProvider
== null) {
771 decorationProvider
.filterApplied(signal
.getEventFilter());
776 * Handler for the Event Search Applied signal
779 * The incoming signal
782 public void searchApplied(TmfEventSearchAppliedSignal signal
) {
783 TimeChartDecorationProvider decorationProvider
= fDecorationProviders
.get(signal
.getTrace());
784 if (decorationProvider
== null) {
787 decorationProvider
.searchApplied(signal
.getSearchFilter());
795 public TmfTimeViewAlignmentInfo
getTimeViewAlignmentInfo() {
796 if (fViewer
== null) {
799 return fViewer
.getTimeViewAlignmentInfo();
806 public int getAvailableWidth(int requestedOffset
) {
807 return fViewer
.getAvailableWidth(requestedOffset
);
814 public void performAlign(int offset
, int width
) {
815 fViewer
.performAlign(offset
, width
);