projects / deliverable / tracecompass.git / blame
? search:
summary | shortlog | log | commit | commitdiff | tree
blob | blame (incremental) | history | HEAD
tmf: Add the Histogram query API to ITmfStatistics
[deliverable/tracecompass.git] / org.eclipse.linuxtools.tmf.ui / src / org / eclipse / linuxtools / tmf / ui / views / timechart / TimeChartView.java
CommitLineData
6151d86c
PT		 1/*******************************************************************************
2 * Copyright (c) 2010 Ericsson
3 *
4 * All rights reserved. This program and the accompanying materials are
5 * made available under the terms of the Eclipse Public License v1.0 which
6 * accompanies this distribution, and is available at
7 * http://www.eclipse.org/legal/epl-v10.html
8 *
9 * Contributors:
10 * Patrick Tasse - Initial API and implementation
11 *******************************************************************************/
12
13package org.eclipse.linuxtools.tmf.ui.views.timechart;
14
15import java.util.ArrayList;
16import java.util.HashMap;
17import java.util.Iterator;
18import java.util.Map;
19
20import org.eclipse.core.resources.IFile;
21import org.eclipse.core.resources.IMarker;
22import org.eclipse.core.resources.IMarkerDelta;
23import org.eclipse.core.resources.IResourceChangeEvent;
24import org.eclipse.core.resources.IResourceChangeListener;
25import org.eclipse.core.resources.IResourceDelta;
26import org.eclipse.core.resources.ResourcesPlugin;
27import org.eclipse.linuxtools.tmf.core.event.ITmfEvent;
28import org.eclipse.linuxtools.tmf.core.event.TmfTimestamp;
29import org.eclipse.linuxtools.tmf.core.filter.ITmfFilter;
30import org.eclipse.linuxtools.tmf.core.signal.TmfSignalHandler;
31import org.eclipse.linuxtools.tmf.core.signal.TmfTimeSynchSignal;
32import org.eclipse.linuxtools.tmf.core.signal.TmfTraceSelectedSignal;
33import org.eclipse.linuxtools.tmf.core.signal.TmfTraceUpdatedSignal;
34import org.eclipse.linuxtools.tmf.core.trace.ITmfContext;
35import org.eclipse.linuxtools.tmf.core.trace.ITmfTrace;
36import org.eclipse.linuxtools.tmf.ui.editors.ITmfTraceEditor;
37import org.eclipse.linuxtools.tmf.ui.signal.TmfTraceClosedSignal;
38import org.eclipse.linuxtools.tmf.ui.signal.TmfTraceOpenedSignal;
39import org.eclipse.linuxtools.tmf.ui.viewers.events.ITmfEventsFilterListener;
40import org.eclipse.linuxtools.tmf.ui.viewers.events.ITmfEventsFilterProvider;
41import org.eclipse.linuxtools.tmf.ui.views.TmfView;
42import org.eclipse.linuxtools.tmf.ui.views.colors.ColorSetting;
43import org.eclipse.linuxtools.tmf.ui.views.colors.ColorSettingsManager;
44import org.eclipse.linuxtools.tmf.ui.views.colors.IColorSettingsListener;
45import org.eclipse.linuxtools.tmf.ui.views.timechart.TimeChartEvent.RankRange;
46import org.eclipse.linuxtools.tmf.ui.widgets.timegraph.ITimeGraphPresentationProvider;
47import org.eclipse.linuxtools.tmf.ui.widgets.timegraph.ITimeGraphRangeListener;
48import org.eclipse.linuxtools.tmf.ui.widgets.timegraph.ITimeGraphSelectionListener;
49import org.eclipse.linuxtools.tmf.ui.widgets.timegraph.ITimeGraphTimeListener;
50import org.eclipse.linuxtools.tmf.ui.widgets.timegraph.TimeGraphRangeUpdateEvent;
51import org.eclipse.linuxtools.tmf.ui.widgets.timegraph.TimeGraphSelectionEvent;
52import org.eclipse.linuxtools.tmf.ui.widgets.timegraph.TimeGraphTimeEvent;
53import org.eclipse.linuxtools.tmf.ui.widgets.timegraph.TimeGraphViewer;
54import org.eclipse.linuxtools.tmf.ui.widgets.timegraph.model.ITimeEvent;
55import org.eclipse.linuxtools.tmf.ui.widgets.timegraph.model.ITimeGraphEntry;
56import org.eclipse.swt.SWT;
57import org.eclipse.swt.widgets.Composite;
58import org.eclipse.swt.widgets.Display;
59import org.eclipse.ui.IEditorPart;
60import org.eclipse.ui.IEditorReference;
61
62/**
63 * Generic Time Chart view, which is similar to a Gantt chart for trace analysis
64 *
65 * @version 1.0
66 * @author Patrick Tasse
67 */
68public class TimeChartView extends TmfView implements ITimeGraphRangeListener,
69 ITimeGraphSelectionListener, ITimeGraphTimeListener,
70 IColorSettingsListener, IResourceChangeListener,
71 ITmfEventsFilterListener {
72
73 /** TimeChartView's ID */
74 public static final String ID = "org.eclipse.linuxtools.tmf.ui.views.timechart"; //$NON-NLS-1$
75
76 private static final int TIMESTAMP_SCALE = -9;
77
78 private final int fDisplayWidth;
79 private TimeGraphViewer fViewer;
80 private final ArrayList<TimeChartAnalysisEntry> fTimeAnalysisEntries = new ArrayList<TimeChartAnalysisEntry>();
81 private final Map<ITmfTrace, TimeChartDecorationProvider> fDecorationProviders = new HashMap<ITmfTrace, TimeChartDecorationProvider>();
82 private ArrayList<DecorateThread> fDecorateThreads;
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;
91
92 /**
93 * Default constructor
94 */
95 public TimeChartView() {
96 super("Time Chart"); //$NON-NLS-1$
97 fDisplayWidth = Display.getDefault().getBounds().width;
98 }
99
100 @Override
101 public void createPartControl(Composite parent) {
102 fViewer = new TimeGraphViewer(parent, SWT.NONE);
103 fPresentationProvider = new TimeChartAnalysisProvider();
104 fViewer.setTimeGraphProvider(fPresentationProvider);
105 fViewer.setTimeCalendarFormat(true);
106 fViewer.addTimeListener(this);
107 fViewer.addRangeListener(this);
108 fViewer.addSelectionListener(this);
109 fViewer.setMinimumItemWidth(1);
110
111 IEditorReference[] editorReferences = getSite().getPage().getEditorReferences();
112 for (IEditorReference editorReference : editorReferences) {
113 IEditorPart editor = editorReference.getEditor(false);
114 if (editor instanceof ITmfTraceEditor) {
115 ITmfTrace trace = ((ITmfTraceEditor) editor).getTrace();
116 if (trace != null) {
117 IFile bookmarksFile = ((ITmfTraceEditor) editor).getBookmarksFile();
118 TimeChartAnalysisEntry timeAnalysisEntry = new TimeChartAnalysisEntry(trace, fDisplayWidth * 2);
119 fTimeAnalysisEntries.add(timeAnalysisEntry);
120 fDecorationProviders.put(trace, new TimeChartDecorationProvider(bookmarksFile));
121 Thread thread = new ProcessTraceThread(timeAnalysisEntry);
122 thread.start();
123 }
124 }
125 }
126 fViewer.setInput(fTimeAnalysisEntries.toArray(new TimeChartAnalysisEntry[0]));
127
128 fDecorateThreads = new ArrayList<DecorateThread>();
129 ColorSettingsManager.addColorSettingsListener(this);
130 ResourcesPlugin.getWorkspace().addResourceChangeListener(this, IResourceChangeEvent.POST_CHANGE);
131 }
132
133 @Override
134 public void dispose() {
135 ResourcesPlugin.getWorkspace().removeResourceChangeListener(this);
136 for (DecorateThread thread : fDecorateThreads) {
137 thread.cancel();
138 }
139 ColorSettingsManager.removeColorSettingsListener(this);
140 super.dispose();
141 }
142
143 @Override
144 public void setFocus() {
145 fViewer.setFocus();
146 }
147
148 private class ProcessTraceThread extends Thread {
149
150 private final TimeChartAnalysisEntry fTimeAnalysisEntry;
151
152 public ProcessTraceThread(TimeChartAnalysisEntry timeAnalysisEntry) {
153 super("ProcessTraceJob:" + timeAnalysisEntry.getName()); //$NON-NLS-1$
154 fTimeAnalysisEntry = timeAnalysisEntry;
155 }
156
157 @Override
158 public void run() {
159 updateTraceEntry(fTimeAnalysisEntry, Long.MAX_VALUE, 0, Long.MAX_VALUE);
160 }
161 }
162
163 private void updateTraceEntry(TimeChartAnalysisEntry timeAnalysisEntry, long stopRank, long startTime, long stopTime) {
164 ITmfTrace trace = timeAnalysisEntry.getTrace();
165 TimeChartDecorationProvider decorationProvider = fDecorationProviders.get(trace);
166 if (decorationProvider == null) {
167 return; // the trace has been closed
168 }
169 ITmfContext context = null;
170 // TmfTimestamp lastTimestamp = null;
171 boolean done = false;
172 while (!done) {
173 synchronized (timeAnalysisEntry) {
174 if (timeAnalysisEntry.getLastRank() >= trace.getNbEvents()) {
175 done = true;
176 break;
177 }
178 if (context == null || context.getRank() != timeAnalysisEntry.getLastRank()) {
179 if (context != null) {
180 context.dispose();
181 }
182 if (timeAnalysisEntry.getLastRank() != -1) {
183 context = trace.seekEvent(timeAnalysisEntry.getLastRank());
184 } else {
185 // context = trace.seekLocation(null);
186 context = trace.seekEvent(0);
187 }
188 }
189 while (true) {
190 long rank = context.getRank();
191 ITmfEvent event = trace.getNext(context);
192 if (event == null) {
193 done = true;
194 break;
195 }
196 // if (!event.getTimestamp().equals(lastTimestamp)) {
197 TimeChartEvent timeEvent = new TimeChartEvent(timeAnalysisEntry, event, rank, decorationProvider);
198 if (timeEvent.getTime() >= startTime && timeEvent.getTime() <= stopTime) {
199 timeAnalysisEntry.addTraceEvent(timeEvent);
200 }
201 // lastTimestamp = event.getTimestamp();
202 // } *** commented out so that color setting priority gets
203 // set even if the event has same time
204 if (context.getRank() == trace.getNbEvents() || context.getRank() == stopRank) {
205 done = true;
206 break;
207 }
208 if (context.getRank() % trace.getCacheSize() == 1) {
209 // break for UI refresh
210 break;
211 }
212 }
213 // timeAnalysisEntry.setLastRank(Math.min(trace.getNbEvents(),
214 // stopRank));
215 timeAnalysisEntry.setLastRank(context.getRank());
216 }
217 redrawViewer(true);
218 }
219 if (context != null) {
220 context.dispose();
221 }
222 }
223
224 private void refreshViewer() {
225 synchronized (fSyncObj) {
226 if (fRefreshBusy) {
227 fRefreshPending = true;
228 return;
229 }
230 fRefreshBusy = true;
231 }
232 // Perform the refresh on the UI thread
233 Display.getDefault().asyncExec(new Runnable() {
234 @Override
235 public void run() {
236 if (fViewer.getControl().isDisposed()) {
237 return;
238 }
239 fViewer.setInput(fTimeAnalysisEntries.toArray(new TimeChartAnalysisEntry[0]));
240 fViewer.resetStartFinishTime();
241 synchronized (fSyncObj) {
242 fRefreshBusy = false;
243 if (fRefreshPending) {
244 fRefreshPending = false;
245 refreshViewer();
246 }
247 }
248 }
249 });
250 }
251
252 private void redrawViewer(boolean resetTimeIntervals) {
253 synchronized (fSyncObj) {
254 if (fRedrawBusy) {
255 fRedrawPending = true;
256 return;
257 }
258 fRedrawBusy = true;
259 }
260 final boolean reset = resetTimeIntervals;
261 // Perform the refresh on the UI thread
262 Display.getDefault().asyncExec(new Runnable() {
263 @Override
264 public void run() {
265 if (fViewer.getControl().isDisposed()) {
266 return;
267 }
268 if (reset) {
269 fViewer.setTimeRange(fTimeAnalysisEntries.toArray(new TimeChartAnalysisEntry[0]));
270 fViewer.setTimeBounds();
271 }
272 fViewer.getControl().redraw();
273 fViewer.getControl().update();
274 synchronized (fSyncObj) {
275 fRedrawBusy = false;
276 if (fRedrawPending) {
277 fRedrawPending = false;
278 redrawViewer(reset);
279 }
280 }
281 }
282 });
283 }
284
285 private void itemize(long startTime, long stopTime) {
286 for (int i = 0; i < fTimeAnalysisEntries.size(); i++) {
287 Thread thread = new ItemizeThread(fTimeAnalysisEntries.get(i), startTime, stopTime);
288 thread.start();
289 }
290 }
291
292 private class ItemizeThread extends Thread {
293
294 private final TimeChartAnalysisEntry fTimeAnalysisEntry;
295 private final long fStartTime;
296 private final long fStopTime;
297 private final long fMaxDuration;
298
299 private ItemizeThread(TimeChartAnalysisEntry timeAnalysisEntry, long startTime, long stopTime) {
300 super("Itemize Thread:" + timeAnalysisEntry.getName()); //$NON-NLS-1$
301 fTimeAnalysisEntry = timeAnalysisEntry;
302 fStartTime = startTime;
303 fStopTime = stopTime;
304 fMaxDuration = 3 * (fStopTime - fStartTime) / fDisplayWidth;
305 }
306
307 @Override
308 public void run() {
309 itemizeTraceEntry(fTimeAnalysisEntry);
310 }
311
312 public void itemizeTraceEntry(TimeChartAnalysisEntry timeAnalysisEntry) {
313 Iterator<ITimeEvent> iterator = timeAnalysisEntry.getTimeEventsIterator();
314 TimeChartEvent event = null;
315 boolean hasNext = true;
316 while (hasNext) {
317 synchronized (timeAnalysisEntry) {
318 while (hasNext = iterator.hasNext()) {
319 event = (TimeChartEvent) iterator.next();
320 if (event.getTime() + event.getDuration() > fStartTime && event.getTime() < fStopTime && event.getDuration() > fMaxDuration
321 && event.getNbEvents() > 1) {
322 break;
323 }
324 }
325 }
326 if (hasNext) {
327 if (event.getItemizedEntry() == null) {
328 itemizeEvent(event);
329 } else {
330 itemizeTraceEntry(event.getItemizedEntry());
331 }
332 }
333 }
334 }
335
336 public void itemizeEvent(TimeChartEvent event) {
337 synchronized (event) {
338 if (event.isItemizing()) {
339 return;
340 }
341 event.setItemizing(true);
342 }
343 TimeChartAnalysisEntry timeAnalysisEntry = new TimeChartAnalysisEntry(fTimeAnalysisEntry.getTrace(), (int) Math.min(
344 event.getNbEvents() + 1, fDisplayWidth * 2));
345 synchronized (event.getRankRangeList()) {
346 for (RankRange range : event.getRankRangeList()) {
347 timeAnalysisEntry.setLastRank(range.getFirstRank());
348 updateTraceEntry(timeAnalysisEntry, range.getLastRank() + 1, event.getTime(), event.getTime() + event.getDuration());
349 }
350 }
351 event.setItemizedEntry(timeAnalysisEntry);
352 redrawViewer(false);
353 itemizeTraceEntry(timeAnalysisEntry);
354 synchronized (event) {
355 event.setItemizing(false);
356 }
357 }
358 }
359
360 private void redecorate() {
361 synchronized (fDecorateThreads) {
362 for (DecorateThread thread : fDecorateThreads) {
363 thread.cancel();
364 }
365 fDecorateThreads.clear();
366 for (int i = 0; i < fTimeAnalysisEntries.size(); i++) {
367 DecorateThread thread = new DecorateThread(fTimeAnalysisEntries.get(i));
368 thread.start();
369 fDecorateThreads.add(thread);
370 }
371 }
372 }
373
374 private class DecorateThread extends Thread {
375 private volatile boolean interrupted = false;
376 private final TimeChartAnalysisEntry fTimeAnalysisEntry;
377 private final TimeChartDecorationProvider fDecorationProvider;
378 private ITmfContext fContext;
379 private int fCount = 0;
380
381 private DecorateThread(TimeChartAnalysisEntry timeAnalysisEntry) {
382 super("Decorate Thread:" + timeAnalysisEntry.getName()); //$NON-NLS-1$
383 fTimeAnalysisEntry = timeAnalysisEntry;
384 fDecorationProvider = fDecorationProviders.get(timeAnalysisEntry.getTrace());
385 }
386
387 @Override
388 public void run() {
389 resetTraceEntry(fTimeAnalysisEntry);
390 redrawViewer(false);
391 decorateTraceEntry(fTimeAnalysisEntry, null);
392 redrawViewer(false);
393 synchronized (fDecorateThreads) {
394 fDecorateThreads.remove(this);
395 }
396 if (fContext != null) {
397 fContext.dispose();
398 }
399 }
400
401 public void resetTraceEntry(TimeChartAnalysisEntry timeAnalysisEntry) {
402 Iterator<ITimeEvent> iterator = timeAnalysisEntry.getTimeEventsIterator();
403 TimeChartEvent event = null;
404 boolean hasNext = true;
405 while (!interrupted && hasNext) {
406 synchronized (timeAnalysisEntry) {
407 while (hasNext = iterator.hasNext()) {
408 event = (TimeChartEvent) iterator.next();
409 break;
410 }
411 }
412 if (hasNext) {
413 // TODO possible concurrency problem here with ItemizeJob
414 event.setColorSettingPriority(ColorSettingsManager.PRIORITY_NONE);
415 if (event.getItemizedEntry() != null) {
416 resetTraceEntry(event.getItemizedEntry());
417 }
418 }
419 }
420 }
421
422 public void decorateTraceEntry(TimeChartAnalysisEntry timeAnalysisEntry, TimeChartEvent parentEvent) {
423 // Set max duration high to ensure iterator does not consider
424 // itemized events
425 Iterator<ITimeEvent> iterator = timeAnalysisEntry.getTimeEventsIterator(0, Long.MAX_VALUE, Long.MAX_VALUE);
426 TimeChartEvent event = null;
427 int entryPriority = ColorSettingsManager.PRIORITY_NONE;
428 boolean entryIsBookmarked = false;
429 boolean entryIsVisible = false;
430 boolean entryIsSearchMatch = false;
431 boolean hasNext = true;
432 while (!interrupted && hasNext) {
433 synchronized (timeAnalysisEntry) {
434 while (hasNext = iterator.hasNext()) {
435 event = (TimeChartEvent) iterator.next();
436 break;
437 }
438 }
439 if (hasNext) {
440 // TODO possible concurrency problem here with ItemizeJob
441 if (event.getItemizedEntry() == null) {
442 decorateEvent(event);
443 } else {
444 decorateTraceEntry(event.getItemizedEntry(), event);
445 }
446 entryPriority = Math.min(entryPriority, event.getColorSettingPriority());
447 entryIsBookmarked |= event.isBookmarked();
448 entryIsVisible |= event.isVisible();
449 entryIsSearchMatch |= event.isSearchMatch();
450 if (++fCount % timeAnalysisEntry.getTrace().getCacheSize() == 0) {
451 redrawViewer(false);
452 }
453 }
454 }
455 if (parentEvent != null) {
456 parentEvent.setColorSettingPriority(entryPriority);
457 parentEvent.setIsBookmarked(entryIsBookmarked);
458 parentEvent.setIsVisible(entryIsVisible);
459 parentEvent.setIsSearchMatch(entryIsSearchMatch);
460 }
461 }
462
463 public void decorateEvent(TimeChartEvent timeChartEvent) {
464 // TODO possible concurrency problem here with ItemizeJob
465 TimeChartAnalysisEntry timeAnalysisEntry = (TimeChartAnalysisEntry) timeChartEvent.getEntry();
466 ITmfTrace trace = timeAnalysisEntry.getTrace();
467 int priority = ColorSettingsManager.PRIORITY_NONE;
468 boolean isBookmarked = false;
469 boolean isVisible = false;
470 boolean isSearchMatch = false;
471 synchronized (timeChartEvent.getRankRangeList()) {
472 for (RankRange range : timeChartEvent.getRankRangeList()) {
473 if (interrupted) {
474 return;
475 }
476 if (fContext == null || fContext.getRank() != range.getFirstRank()) {
477 if (fContext != null) {
478 fContext.dispose();
479 }
480 fContext = trace.seekEvent(range.getFirstRank());
481 fContext.setRank(range.getFirstRank());
482 }
483 while (true) {
484 if (interrupted) {
485 return;
486 }
487 long rank = fContext.getRank();
488 ITmfEvent event = trace.getNext(fContext);
489 if (event == null) {
490 break;
491 }
492 long eventTime = event.getTimestamp().normalize(0, -9).getValue();
493 if (eventTime >= timeChartEvent.getTime() && eventTime <= timeChartEvent.getTime() + timeChartEvent.getDuration()) {
494 priority = Math.min(priority, ColorSettingsManager.getColorSettingPriority(event));
495 }
496 isBookmarked |= fDecorationProvider.isBookmark(rank);
497 isVisible |= fDecorationProvider.isVisible(event);
498 isSearchMatch |= fDecorationProvider.isSearchMatch(event);
499 if (fContext.getRank() > range.getLastRank()) {
500 break;
501 }
502 }
503 }
504 }
505 timeChartEvent.setColorSettingPriority(priority);
506 timeChartEvent.setIsBookmarked(isBookmarked);
507 timeChartEvent.setIsVisible(isVisible);
508 timeChartEvent.setIsSearchMatch(isSearchMatch);
509 }
510
511 public void cancel() {
512 interrupted = true;
513 }
514 }
515
516 // ------------------------------------------------------------------------
517 // Listeners
518 // ------------------------------------------------------------------------
519
520 @Override
521 public void timeRangeUpdated(TimeGraphRangeUpdateEvent event) {
522 fStartTime = event.getStartTime();
523 fStopTime = event.getEndTime();
524 itemize(fStartTime, fStopTime);
525 }
526
527 @Override
528 public void selectionChanged(TimeGraphSelectionEvent event) {
529 ITimeGraphEntry timeAnalysisEntry = null;
530 if (event.getSelection() instanceof TimeChartAnalysisEntry) {
531 timeAnalysisEntry = event.getSelection();
532 } else if (event.getSelection() instanceof TimeChartEvent) {
533 timeAnalysisEntry = ((TimeChartEvent) event.getSelection()).getEntry();
534 }
535 if (timeAnalysisEntry instanceof TimeChartAnalysisEntry) {
536 broadcast(new TmfTraceSelectedSignal(this, ((TimeChartAnalysisEntry) timeAnalysisEntry).getTrace()));
537 }
538 }
539
540 @Override
541 public void timeSelected(TimeGraphTimeEvent event) {
542 broadcast(new TmfTimeSynchSignal(this, new TmfTimestamp(event.getTime(), TIMESTAMP_SCALE)));
543 }
544
545 @Override
546 public void colorSettingsChanged(ColorSetting[] colorSettings) {
547 // Set presentation provider again to trigger re-creation of new color settings which are stored
548 // in the TimeGraphControl class
549 fViewer.setTimeGraphProvider(fPresentationProvider);
550 redecorate();
551 }
552
553 @Override
554 public void resourceChanged(IResourceChangeEvent event) {
555 for (IMarkerDelta delta : event.findMarkerDeltas(IMarker.BOOKMARK, false)) {
556 for (TimeChartDecorationProvider provider : fDecorationProviders.values()) {
557 if (delta.getResource().equals(provider.getBookmarksFile())) {
558 if (delta.getKind() == IResourceDelta.CHANGED && delta.getMarker().getAttribute(IMarker.LOCATION, -1) != -1) {
559 provider.refreshBookmarks();
560 } else if (delta.getKind() == IResourceDelta.REMOVED) {
561 provider.refreshBookmarks();
562 }
563 }
564 }
565 }
566 redecorate();
567 }
568
569 @Override
570 public void filterApplied(ITmfFilter filter, ITmfTrace trace) {
571 TimeChartDecorationProvider decorationProvider = fDecorationProviders.get(trace);
572 decorationProvider.filterApplied(filter);
573 redecorate();
574 }
575
576 @Override
577 public void searchApplied(ITmfFilter filter, ITmfTrace trace) {
578 TimeChartDecorationProvider decorationProvider = fDecorationProviders.get(trace);
579 decorationProvider.searchApplied(filter);
580 redecorate();
581 }
582
583 // ------------------------------------------------------------------------
584 // Signal handlers
585 // ------------------------------------------------------------------------
586
587 /**
588 * Handler for the Trace Opened signal
589 *
590 * @param signal
591 * The incoming signal
592 */
593 @TmfSignalHandler
594 public void traceOpened(TmfTraceOpenedSignal signal) {
595 if (fTimeAnalysisEntries == null) {
596 return;
597 }
598 final ITmfTrace trace = signal.getTrace();
599 final IFile bookmarksFile = signal.getBookmarksFile();
600 final ITmfEventsFilterProvider eventsFilterProvider = signal.getEventsFilterProvider();
601 TimeChartAnalysisEntry timeAnalysisEntry = null;
602 for (int i = 0; i < fTimeAnalysisEntries.size(); i++) {
603 if (fTimeAnalysisEntries.get(i).getTrace().equals(trace)) {
604 timeAnalysisEntry = fTimeAnalysisEntries.get(i);
605 break;
606 }
607 }
608 if (timeAnalysisEntry == null) {
609 timeAnalysisEntry = new TimeChartAnalysisEntry(trace, fDisplayWidth * 2);
610 fTimeAnalysisEntries.add(timeAnalysisEntry);
611 fDecorationProviders.put(trace, new TimeChartDecorationProvider(bookmarksFile));
612 Thread thread = new ProcessTraceThread(timeAnalysisEntry);
613 thread.start();
614 }
615 refreshViewer();
616 if (eventsFilterProvider != null) {
617 eventsFilterProvider.addEventsFilterListener(this);
618 }
619 }
620
621 /**
622 * Handler for the Trace Closed signal
623 *
624 * @param signal
625 * The incoming signal
626 */
627 @TmfSignalHandler
628 public void traceClosed(TmfTraceClosedSignal signal) {
629 if (fTimeAnalysisEntries == null) {
630 return;
631 }
632 final ITmfTrace trace = signal.getTrace();
633 for (int i = 0; i < fTimeAnalysisEntries.size(); i++) {
634 if (fTimeAnalysisEntries.get(i).getTrace().equals(trace)) {
635 fTimeAnalysisEntries.remove(i);
636 fDecorationProviders.remove(trace);
637 refreshViewer();
638 break;
639 }
640 }
641 }
642
643 /**
644 * Handler for the Trace Selected signal
645 *
646 * @param signal
647 * The incoming signal
648 */
649 @TmfSignalHandler
650 public void traceSelected(TmfTraceSelectedSignal signal) {
651 if (signal.getSource() != this && fTimeAnalysisEntries != null) {
652 ITmfTrace trace = signal.getTrace();
653 for (int i = 0; i < fTimeAnalysisEntries.size(); i++) {
654 if (fTimeAnalysisEntries.get(i).getTrace().equals(trace)) {
655 fViewer.setSelection(fTimeAnalysisEntries.get(i));
656 break;
657 }
658 }
659 }
660 }
661
662 /**
663 * Handler for the Trace Updated signal
664 *
665 * @param signal
666 * The incoming signal
667 */
668 @TmfSignalHandler
669 public void traceUpdated(TmfTraceUpdatedSignal signal) {
670 if (fTimeAnalysisEntries == null) {
671 return;
672 }
673 final ITmfTrace trace = signal.getTrace();
674 for (int i = 0; i < fTimeAnalysisEntries.size(); i++) {
675 TimeChartAnalysisEntry timeAnalysisEntry = fTimeAnalysisEntries.get(i);
676 if (timeAnalysisEntry.getTrace().equals(trace)) {
677 updateTraceEntry(timeAnalysisEntry, Long.MAX_VALUE, 0, Long.MAX_VALUE);
678 break;
679 }
680 }
681 }
682
683 /**
684 * Handler for the Time Synch signal
685 *
686 * @param signal
687 * The incoming signal
688 */
689 @TmfSignalHandler
690 public void currentTimeUpdated(TmfTimeSynchSignal signal) {
691 final long time = signal.getCurrentTime().normalize(0, TIMESTAMP_SCALE).getValue();
692 Display.getDefault().asyncExec(new Runnable() {
693 @Override
694 public void run() {
695 fViewer.setSelectedTime(time, true);
696 }
697 });
698 }
699
700}
Tracecompass - Deliverables
This page took 0.067247 seconds and 5 git commands to generate.