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