projects / deliverable / tracecompass.git / blame
? search:
summary | shortlog | log | commit | commitdiff | tree
blob | blame (incremental) | history | HEAD
tmf: Bug 494952: Remove deadlock in Time Chart view
[deliverable/tracecompass.git] / tmf / org.eclipse.tracecompass.tmf.ui / src / org / eclipse / tracecompass / tmf / ui / views / timechart / TimeChartView.java
CommitLineData
6151d86c 1/*******************************************************************************
b1ba6312 2 * Copyright (c) 2010, 2016 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
2bdf0193 13package org.eclipse.tracecompass.tmf.ui.views.timechart;
6151d86c
PT		 14
15import java.util.ArrayList;
16import java.util.HashMap;
17import java.util.Iterator;
1337fefc 18import java.util.List;
6151d86c
PT		 19import java.util.Map;
20
21import org.eclipse.core.resources.IFile;
22import org.eclipse.core.resources.IMarker;
23import org.eclipse.core.resources.IMarkerDelta;
24import org.eclipse.core.resources.IResourceChangeEvent;
25import org.eclipse.core.resources.IResourceChangeListener;
26import org.eclipse.core.resources.IResourceDelta;
27import org.eclipse.core.resources.ResourcesPlugin;
0fcf3b09 28import org.eclipse.jface.action.IStatusLineManager;
6151d86c
PT		 29import org.eclipse.swt.SWT;
30import org.eclipse.swt.widgets.Composite;
31import org.eclipse.swt.widgets.Display;
2bdf0193 32import org.eclipse.tracecompass.tmf.core.event.ITmfEvent;
b1ba6312 33import org.eclipse.tracecompass.tmf.core.resources.ITmfMarker;
2bdf0193
AM		 34import org.eclipse.tracecompass.tmf.core.signal.TmfEventFilterAppliedSignal;
35import org.eclipse.tracecompass.tmf.core.signal.TmfEventSearchAppliedSignal;
97c71024 36import org.eclipse.tracecompass.tmf.core.signal.TmfSelectionRangeUpdatedSignal;
d2e4afa7 37import org.eclipse.tracecompass.tmf.core.signal.TmfSignalHandler;
2bdf0193
AM		 38import org.eclipse.tracecompass.tmf.core.signal.TmfTraceClosedSignal;
39import org.eclipse.tracecompass.tmf.core.signal.TmfTraceOpenedSignal;
40import org.eclipse.tracecompass.tmf.core.signal.TmfTraceSelectedSignal;
41import org.eclipse.tracecompass.tmf.core.signal.TmfTraceUpdatedSignal;
d2e4afa7 42import org.eclipse.tracecompass.tmf.core.signal.TmfWindowRangeUpdatedSignal;
2bdf0193
AM		 43import org.eclipse.tracecompass.tmf.core.timestamp.ITmfTimestamp;
44import org.eclipse.tracecompass.tmf.core.timestamp.TmfTimeRange;
45import org.eclipse.tracecompass.tmf.core.timestamp.TmfTimestamp;
46import org.eclipse.tracecompass.tmf.core.trace.ITmfContext;
47import org.eclipse.tracecompass.tmf.core.trace.ITmfTrace;
21852dfa 48import org.eclipse.tracecompass.tmf.core.trace.TmfTraceContext;
2bdf0193 49import org.eclipse.tracecompass.tmf.core.trace.TmfTraceManager;
d2e4afa7
MAL		 50import org.eclipse.tracecompass.tmf.ui.signal.TmfTimeViewAlignmentInfo;
51import org.eclipse.tracecompass.tmf.ui.views.ITmfTimeAligned;
2bdf0193
AM		 52import org.eclipse.tracecompass.tmf.ui.views.TmfView;
53import org.eclipse.tracecompass.tmf.ui.views.colors.ColorSetting;
54import org.eclipse.tracecompass.tmf.ui.views.colors.ColorSettingsManager;
55import org.eclipse.tracecompass.tmf.ui.views.colors.IColorSettingsListener;
56import org.eclipse.tracecompass.tmf.ui.views.timechart.TimeChartEvent.RankRange;
57import org.eclipse.tracecompass.tmf.ui.widgets.timegraph.ITimeGraphPresentationProvider;
58import org.eclipse.tracecompass.tmf.ui.widgets.timegraph.ITimeGraphRangeListener;
59import org.eclipse.tracecompass.tmf.ui.widgets.timegraph.ITimeGraphSelectionListener;
60import org.eclipse.tracecompass.tmf.ui.widgets.timegraph.ITimeGraphTimeListener;
61import org.eclipse.tracecompass.tmf.ui.widgets.timegraph.TimeGraphRangeUpdateEvent;
62import org.eclipse.tracecompass.tmf.ui.widgets.timegraph.TimeGraphSelectionEvent;
63import org.eclipse.tracecompass.tmf.ui.widgets.timegraph.TimeGraphTimeEvent;
64import org.eclipse.tracecompass.tmf.ui.widgets.timegraph.TimeGraphViewer;
65import org.eclipse.tracecompass.tmf.ui.widgets.timegraph.model.ITimeEvent;
66import org.eclipse.tracecompass.tmf.ui.widgets.timegraph.model.ITimeGraphEntry;
67import org.eclipse.tracecompass.tmf.ui.widgets.timegraph.widgets.Utils.TimeFormat;
6151d86c
PT		 68
69/**
70 * Generic Time Chart view, which is similar to a Gantt chart for trace analysis
71 *
72 * @version 1.0
73 * @author Patrick Tasse
74 */
d2e4afa7 75public class TimeChartView extends TmfView implements ITimeGraphRangeListener, ITimeGraphSelectionListener, ITimeGraphTimeListener, IColorSettingsListener, IResourceChangeListener, ITmfTimeAligned {
6151d86c
PT		 76
77 /** TimeChartView's ID */
78 public static final String ID = "org.eclipse.linuxtools.tmf.ui.views.timechart"; //$NON-NLS-1$
79
6151d86c
PT		 80 private final int fDisplayWidth;
81 private TimeGraphViewer fViewer;
1337fefc 82 private final List<TimeChartAnalysisEntry> fTimeAnalysisEntries = new ArrayList<>();
507b1336 83 private final Map<ITmfTrace, TimeChartDecorationProvider> fDecorationProviders = new HashMap<>();
1337fefc 84 private final List<DecorateThread> fDecorateThreads = new ArrayList<>();
7255573c 85 private final Map<ITmfTrace, ProcessTraceThread> fProcessTraceThreads = new HashMap<>();
6151d86c
PT		 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;
94
95 /**
96 * Default constructor
97 */
98 public TimeChartView() {
99 super("Time Chart"); //$NON-NLS-1$
100 fDisplayWidth = Display.getDefault().getBounds().width;
101 }
102
103 @Override
104 public void createPartControl(Composite parent) {
d2e4afa7 105 super.createPartControl(parent);
ad128fd8 106 fViewer = new TimeGraphViewer(parent, SWT.NONE);
6151d86c
PT		 107 fPresentationProvider = new TimeChartAnalysisProvider();
108 fViewer.setTimeGraphProvider(fPresentationProvider);
026664b7 109 fViewer.setTimeFormat(TimeFormat.CALENDAR);
6151d86c
PT		 110 fViewer.addTimeListener(this);
111 fViewer.addRangeListener(this);
112 fViewer.addSelectionListener(this);
113 fViewer.setMinimumItemWidth(1);
b052914f 114 fViewer.getTimeGraphControl().setBlendSubPixelEvents(true);
6151d86c 115
0fcf3b09
PT		 116 IStatusLineManager statusLineManager = getViewSite().getActionBars().getStatusLineManager();
117 fViewer.getTimeGraphControl().setStatusLineManager(statusLineManager);
118
deaae6e1
PT		 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));
7255573c 124 startProcessTraceThread(timeAnalysisEntry);
6151d86c
PT		 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);
7255573c
PT		 135 synchronized (fDecorateThreads) {
136 for (DecorateThread thread : fDecorateThreads) {
137 thread.cancel();
138 }
6151d86c
PT		 139 }
140 ColorSettingsManager.removeColorSettingsListener(this);
141 super.dispose();
142 }
143
144 @Override
145 public void setFocus() {
146 fViewer.setFocus();
147 }
148
7255573c
PT		 149 private void startProcessTraceThread(TimeChartAnalysisEntry entry) {
150 synchronized (fProcessTraceThreads) {
151 ProcessTraceThread thread = fProcessTraceThreads.get(entry.getTrace());
152 if (thread != null) {
153 thread.restart();
154 } else {
155 thread = new ProcessTraceThread(entry);
156 fProcessTraceThreads.put(entry.getTrace(), thread);
157 thread.start();
158 }
159 }
160 }
161
6151d86c
PT		 162 private class ProcessTraceThread extends Thread {
163
164 private final TimeChartAnalysisEntry fTimeAnalysisEntry;
7255573c 165 private boolean fRestart;
6151d86c
PT		 166
167 public ProcessTraceThread(TimeChartAnalysisEntry timeAnalysisEntry) {
168 super("ProcessTraceJob:" + timeAnalysisEntry.getName()); //$NON-NLS-1$
169 fTimeAnalysisEntry = timeAnalysisEntry;
170 }
171
7255573c
PT		 172 public void restart() {
173 synchronized (fProcessTraceThreads) {
174 fRestart = true;
175 }
176 }
177
6151d86c
PT		 178 @Override
179 public void run() {
7255573c
PT		 180 while (true) {
181 updateTraceEntry(fTimeAnalysisEntry, Long.MAX_VALUE,
182 TmfTimestamp.BIG_BANG.toNanos(),
183 TmfTimestamp.BIG_CRUNCH.toNanos());
184 synchronized (fProcessTraceThreads) {
185 if (fRestart) {
186 fRestart = false;
187 } else {
188 fProcessTraceThreads.remove(fTimeAnalysisEntry.getTrace());
189 return;
190 }
191 }
192 }
6151d86c
PT		 193 }
194 }
195
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
201 }
202 ITmfContext context = null;
203 // TmfTimestamp lastTimestamp = null;
204 boolean done = false;
205 while (!done) {
206 synchronized (timeAnalysisEntry) {
207 if (timeAnalysisEntry.getLastRank() >= trace.getNbEvents()) {
208 done = true;
209 break;
210 }
211 if (context == null || context.getRank() != timeAnalysisEntry.getLastRank()) {
212 if (context != null) {
213 context.dispose();
214 }
215 if (timeAnalysisEntry.getLastRank() != -1) {
216 context = trace.seekEvent(timeAnalysisEntry.getLastRank());
217 } else {
218 // context = trace.seekLocation(null);
219 context = trace.seekEvent(0);
220 }
221 }
222 while (true) {
223 long rank = context.getRank();
224 ITmfEvent event = trace.getNext(context);
225 if (event == null) {
226 done = true;
227 break;
228 }
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);
233 }
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) {
238 done = true;
239 break;
240 }
241 if (context.getRank() % trace.getCacheSize() == 1) {
242 // break for UI refresh
243 break;
244 }
245 }
246 // timeAnalysisEntry.setLastRank(Math.min(trace.getNbEvents(),
247 // stopRank));
248 timeAnalysisEntry.setLastRank(context.getRank());
249 }
250 redrawViewer(true);
251 }
252 if (context != null) {
253 context.dispose();
254 }
255 }
256
257 private void refreshViewer() {
258 synchronized (fSyncObj) {
259 if (fRefreshBusy) {
260 fRefreshPending = true;
261 return;
262 }
263 fRefreshBusy = true;
264 }
265 // Perform the refresh on the UI thread
266 Display.getDefault().asyncExec(new Runnable() {
267 @Override
268 public void run() {
269 if (fViewer.getControl().isDisposed()) {
270 return;
271 }
272 fViewer.setInput(fTimeAnalysisEntries.toArray(new TimeChartAnalysisEntry[0]));
7255573c 273 fViewer.resetStartFinishTime(false);
6151d86c
PT		 274 synchronized (fSyncObj) {
275 fRefreshBusy = false;
276 if (fRefreshPending) {
277 fRefreshPending = false;
278 refreshViewer();
279 }
280 }
281 }
282 });
283 }
284
285 private void redrawViewer(boolean resetTimeIntervals) {
286 synchronized (fSyncObj) {
287 if (fRedrawBusy) {
288 fRedrawPending = true;
289 return;
290 }
291 fRedrawBusy = true;
292 }
293 final boolean reset = resetTimeIntervals;
294 // Perform the refresh on the UI thread
295 Display.getDefault().asyncExec(new Runnable() {
296 @Override
297 public void run() {
298 if (fViewer.getControl().isDisposed()) {
299 return;
300 }
301 if (reset) {
302 fViewer.setTimeRange(fTimeAnalysisEntries.toArray(new TimeChartAnalysisEntry[0]));
303 fViewer.setTimeBounds();
304 }
305 fViewer.getControl().redraw();
306 fViewer.getControl().update();
307 synchronized (fSyncObj) {
308 fRedrawBusy = false;
309 if (fRedrawPending) {
310 fRedrawPending = false;
311 redrawViewer(reset);
312 }
313 }
314 }
315 });
316 }
317
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);
321 thread.start();
322 }
323 }
324
325 private class ItemizeThread extends Thread {
326
327 private final TimeChartAnalysisEntry fTimeAnalysisEntry;
3dca7aa5
AM		 328 private final long startTime;
329 private final long stopTime;
6151d86c
PT		 330 private final long fMaxDuration;
331
332 private ItemizeThread(TimeChartAnalysisEntry timeAnalysisEntry, long startTime, long stopTime) {
333 super("Itemize Thread:" + timeAnalysisEntry.getName()); //$NON-NLS-1$
334 fTimeAnalysisEntry = timeAnalysisEntry;
3dca7aa5
AM		 335 this.startTime = startTime;
336 this.stopTime = stopTime;
337 fMaxDuration = 3 * (stopTime - startTime) / fDisplayWidth;
6151d86c
PT		 338 }
339
340 @Override
341 public void run() {
342 itemizeTraceEntry(fTimeAnalysisEntry);
343 }
344
345 public void itemizeTraceEntry(TimeChartAnalysisEntry timeAnalysisEntry) {
346 Iterator<ITimeEvent> iterator = timeAnalysisEntry.getTimeEventsIterator();
347 TimeChartEvent event = null;
348 boolean hasNext = true;
349 while (hasNext) {
350 synchronized (timeAnalysisEntry) {
3dca7aa5 351 while ((hasNext = iterator.hasNext()) == true) {
6151d86c 352 event = (TimeChartEvent) iterator.next();
3dca7aa5 353 if (event.getTime() + event.getDuration() > startTime && event.getTime() < stopTime && event.getDuration() > fMaxDuration
6151d86c
PT		 354 && event.getNbEvents() > 1) {
355 break;
356 }
357 }
358 }
3dca7aa5 359 if (hasNext && event != null) {
6151d86c
PT		 360 if (event.getItemizedEntry() == null) {
361 itemizeEvent(event);
362 } else {
363 itemizeTraceEntry(event.getItemizedEntry());
364 }
365 }
366 }
367 }
368
369 public void itemizeEvent(TimeChartEvent event) {
370 synchronized (event) {
371 if (event.isItemizing()) {
372 return;
373 }
374 event.setItemizing(true);
375 }
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());
382 }
383 }
384 event.setItemizedEntry(timeAnalysisEntry);
385 redrawViewer(false);
386 itemizeTraceEntry(timeAnalysisEntry);
387 synchronized (event) {
388 event.setItemizing(false);
389 }
390 }
391 }
392
393 private void redecorate() {
394 synchronized (fDecorateThreads) {
395 for (DecorateThread thread : fDecorateThreads) {
396 thread.cancel();
397 }
398 fDecorateThreads.clear();
399 for (int i = 0; i < fTimeAnalysisEntries.size(); i++) {
400 DecorateThread thread = new DecorateThread(fTimeAnalysisEntries.get(i));
401 thread.start();
402 fDecorateThreads.add(thread);
403 }
404 }
405 }
406
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;
413
414 private DecorateThread(TimeChartAnalysisEntry timeAnalysisEntry) {
415 super("Decorate Thread:" + timeAnalysisEntry.getName()); //$NON-NLS-1$
416 fTimeAnalysisEntry = timeAnalysisEntry;
417 fDecorationProvider = fDecorationProviders.get(timeAnalysisEntry.getTrace());
418 }
419
420 @Override
421 public void run() {
422 resetTraceEntry(fTimeAnalysisEntry);
423 redrawViewer(false);
424 decorateTraceEntry(fTimeAnalysisEntry, null);
425 redrawViewer(false);
426 synchronized (fDecorateThreads) {
427 fDecorateThreads.remove(this);
428 }
429 if (fContext != null) {
faa38350 430 fContext.dispose();
6151d86c
PT		 431 }
432 }
433
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) {
3dca7aa5 440 while ((hasNext = iterator.hasNext()) == true) {
6151d86c
PT		 441 event = (TimeChartEvent) iterator.next();
442 break;
443 }
444 }
3dca7aa5 445 if (hasNext && event != null) {
6151d86c
PT		 446 // TODO possible concurrency problem here with ItemizeJob
447 event.setColorSettingPriority(ColorSettingsManager.PRIORITY_NONE);
448 if (event.getItemizedEntry() != null) {
449 resetTraceEntry(event.getItemizedEntry());
450 }
451 }
452 }
453 }
454
455 public void decorateTraceEntry(TimeChartAnalysisEntry timeAnalysisEntry, TimeChartEvent parentEvent) {
456 // Set max duration high to ensure iterator does not consider
457 // itemized events
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) {
3dca7aa5 467 while ((hasNext = iterator.hasNext()) == true) {
6151d86c
PT		 468 event = (TimeChartEvent) iterator.next();
469 break;
470 }
471 }
3dca7aa5 472 if (hasNext && event != null) {
6151d86c
PT		 473 // TODO possible concurrency problem here with ItemizeJob
474 if (event.getItemizedEntry() == null) {
475 decorateEvent(event);
476 } else {
477 decorateTraceEntry(event.getItemizedEntry(), event);
478 }
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) {
484 redrawViewer(false);
485 }
486 }
487 }
488 if (parentEvent != null) {
489 parentEvent.setColorSettingPriority(entryPriority);
490 parentEvent.setIsBookmarked(entryIsBookmarked);
491 parentEvent.setIsVisible(entryIsVisible);
492 parentEvent.setIsSearchMatch(entryIsSearchMatch);
493 }
494 }
495
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()) {
506 if (interrupted) {
507 return;
508 }
509 if (fContext == null || fContext.getRank() != range.getFirstRank()) {
510 if (fContext != null) {
faa38350 511 fContext.dispose();
6151d86c
PT		 512 }
513 fContext = trace.seekEvent(range.getFirstRank());
514 fContext.setRank(range.getFirstRank());
515 }
516 while (true) {
517 if (interrupted) {
518 return;
519 }
520 long rank = fContext.getRank();
521 ITmfEvent event = trace.getNext(fContext);
522 if (event == null) {
523 break;
524 }
16801c72 525 long eventTime = event.getTimestamp().toNanos();
6151d86c
PT		 526 if (eventTime >= timeChartEvent.getTime() && eventTime <= timeChartEvent.getTime() + timeChartEvent.getDuration()) {
527 priority = Math.min(priority, ColorSettingsManager.getColorSettingPriority(event));
528 }
529 isBookmarked |= fDecorationProvider.isBookmark(rank);
530 isVisible |= fDecorationProvider.isVisible(event);
531 isSearchMatch |= fDecorationProvider.isSearchMatch(event);
532 if (fContext.getRank() > range.getLastRank()) {
533 break;
534 }
535 }
536 }
537 }
538 timeChartEvent.setColorSettingPriority(priority);
539 timeChartEvent.setIsBookmarked(isBookmarked);
540 timeChartEvent.setIsVisible(isVisible);
541 timeChartEvent.setIsSearchMatch(isSearchMatch);
542 }
543
544 public void cancel() {
545 interrupted = true;
546 }
547 }
548
549 // ------------------------------------------------------------------------
550 // Listeners
551 // ------------------------------------------------------------------------
552
553 @Override
554 public void timeRangeUpdated(TimeGraphRangeUpdateEvent event) {
555 fStartTime = event.getStartTime();
556 fStopTime = event.getEndTime();
557 itemize(fStartTime, fStopTime);
b2c971ec
MK		 558 final ITmfTimestamp startTimestamp = TmfTimestamp.fromNanos(event.getStartTime());
559 final ITmfTimestamp endTimestamp = TmfTimestamp.fromNanos(event.getEndTime());
faa38350 560 TmfTimeRange range = new TmfTimeRange(startTimestamp, endTimestamp);
97c71024 561 broadcast(new TmfWindowRangeUpdatedSignal(this, range));
6151d86c
PT		 562 }
563
564 @Override
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();
571 }
572 if (timeAnalysisEntry instanceof TimeChartAnalysisEntry) {
573 broadcast(new TmfTraceSelectedSignal(this, ((TimeChartAnalysisEntry) timeAnalysisEntry).getTrace()));
574 }
575 }
576
577 @Override
578 public void timeSelected(TimeGraphTimeEvent event) {
b2c971ec 579 broadcast(new TmfSelectionRangeUpdatedSignal(this, TmfTimestamp.fromNanos(event.getBeginTime()), TmfTimestamp.fromNanos(event.getEndTime())));
6151d86c
PT		 580 }
581
582 @Override
583 public void colorSettingsChanged(ColorSetting[] colorSettings) {
a049a5e7
MK		 584 // Set presentation provider again to trigger re-creation of new color
585 // settings which are stored in the TimeGraphControl class
6151d86c
PT		 586 fViewer.setTimeGraphProvider(fPresentationProvider);
587 redecorate();
588 }
589
590 @Override
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())) {
b1ba6312
PT		 595 if (delta.getKind() == IResourceDelta.REMOVED ||
596 delta.getMarker().getAttribute(IMarker.LOCATION, -1) != -1 ||
597 delta.getMarker().getAttribute(ITmfMarker.MARKER_RANK, (String) null) != null) {
6151d86c
PT		 598 provider.refreshBookmarks();
599 }
600 }
601 }
602 }
603 redecorate();
604 }
605
6151d86c
PT		 606 // ------------------------------------------------------------------------
607 // Signal handlers
608 // ------------------------------------------------------------------------
609
610 /**
611 * Handler for the Trace Opened signal
612 *
613 * @param signal
614 * The incoming signal
615 */
616 @TmfSignalHandler
617 public void traceOpened(TmfTraceOpenedSignal signal) {
6151d86c 618 final ITmfTrace trace = signal.getTrace();
deaae6e1 619 final IFile bookmarksFile = signal.getEditorFile();
6151d86c
PT		 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);
624 break;
625 }
626 }
627 if (timeAnalysisEntry == null) {
628 timeAnalysisEntry = new TimeChartAnalysisEntry(trace, fDisplayWidth * 2);
629 fTimeAnalysisEntries.add(timeAnalysisEntry);
630 fDecorationProviders.put(trace, new TimeChartDecorationProvider(bookmarksFile));
7255573c 631 startProcessTraceThread(timeAnalysisEntry);
6151d86c
PT		 632 }
633 refreshViewer();
6151d86c
PT		 634 }
635
636 /**
637 * Handler for the Trace Closed signal
638 *
639 * @param signal
640 * The incoming signal
641 */
642 @TmfSignalHandler
643 public void traceClosed(TmfTraceClosedSignal signal) {
6151d86c
PT		 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);
faa38350
PT		 649 synchronized (fDecorateThreads) {
650 for (DecorateThread thread : fDecorateThreads) {
651 if (thread.fTimeAnalysisEntry.getTrace() == trace) {
652 thread.cancel();
653 fDecorateThreads.remove(thread);
654 break;
655 }
656 }
657 }
6151d86c
PT		 658 refreshViewer();
659 break;
660 }
661 }
662 }
663
664 /**
665 * Handler for the Trace Selected signal
666 *
667 * @param signal
668 * The incoming signal
669 */
670 @TmfSignalHandler
671 public void traceSelected(TmfTraceSelectedSignal signal) {
77fdc5df 672 if (signal.getSource() != this) {
6151d86c
PT		 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));
677 break;
678 }
679 }
21852dfa 680 TmfTraceContext ctx = TmfTraceManager.getInstance().getCurrentTraceContext();
16801c72
MK		 681 long beginTime = ctx.getSelectionRange().getStartTime().toNanos();
682 long endTime = ctx.getSelectionRange().getEndTime().toNanos();
84c8aef7 683 fViewer.setSelectionRange(beginTime, endTime, false);
6151d86c
PT		 684 }
685 }
686
687 /**
688 * Handler for the Trace Updated signal
689 *
690 * @param signal
691 * The incoming signal
692 */
693 @TmfSignalHandler
694 public void traceUpdated(TmfTraceUpdatedSignal signal) {
6151d86c
PT		 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)) {
7255573c 699 startProcessTraceThread(timeAnalysisEntry);
6151d86c
PT		 700 break;
701 }
702 }
703 }
704
705 /**
97c71024 706 * Handler for the selection range updated signal.
6151d86c
PT		 707 *
708 * @param signal
709 * The incoming signal
97c71024 710 * @since 1.0
6151d86c
PT		 711 */
712 @TmfSignalHandler
97c71024 713 public void selectionRangeUpdated(TmfSelectionRangeUpdatedSignal signal) {
16801c72
MK		 714 final long beginTime = signal.getBeginTime().toNanos();
715 final long endTime = signal.getEndTime().toNanos();
716
6151d86c
PT		 717 Display.getDefault().asyncExec(new Runnable() {
718 @Override
719 public void run() {
0fcf3b09
PT		 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);
726 }
727 } else {
84c8aef7 728 fViewer.setSelectionRange(beginTime, endTime, true);
0fcf3b09 729 }
6151d86c
PT		 730 }
731 });
732 }
733
faa38350 734 /**
97c71024 735 * Handler for the window range updated signal.
faa38350
PT		 736 *
737 * @param signal
738 * The incoming signal
97c71024 739 * @since 1.0
faa38350
PT		 740 */
741 @TmfSignalHandler
97c71024 742 public void windowRangeUpdated(final TmfWindowRangeUpdatedSignal signal) {
faa38350
PT		 743 if (signal.getSource() == this) {
744 return;
745 }
16801c72
MK		 746 final long startTime = signal.getCurrentRange().getStartTime().toNanos();
747 final long endTime = signal.getCurrentRange().getEndTime().toNanos();
faa38350
PT		 748 Display.getDefault().asyncExec(new Runnable() {
749 @Override
750 public void run() {
751 fStartTime = startTime;
752 fStopTime = endTime;
753 itemize(fStartTime, fStopTime);
754 fViewer.setStartFinishTime(startTime, endTime);
faa38350
PT		 755 }
756 });
757 }
758
759 /**
760 * Handler for the Event Filter Applied signal
761 *
762 * @param signal
763 * The incoming signal
faa38350
PT		 764 */
765 @TmfSignalHandler
766 public void filterApplied(TmfEventFilterAppliedSignal signal) {
767 TimeChartDecorationProvider decorationProvider = fDecorationProviders.get(signal.getTrace());
768 if (decorationProvider == null) {
769 return;
770 }
771 decorationProvider.filterApplied(signal.getEventFilter());
772 redecorate();
773 }
774
775 /**
776 * Handler for the Event Search Applied signal
777 *
778 * @param signal
779 * The incoming signal
faa38350
PT		 780 */
781 @TmfSignalHandler
782 public void searchApplied(TmfEventSearchAppliedSignal signal) {
783 TimeChartDecorationProvider decorationProvider = fDecorationProviders.get(signal.getTrace());
784 if (decorationProvider == null) {
785 return;
786 }
787 decorationProvider.searchApplied(signal.getSearchFilter());
788 redecorate();
789 }
790
d2e4afa7
MAL		 791 /**
792 * @since 1.0
793 */
794 @Override
795 public TmfTimeViewAlignmentInfo getTimeViewAlignmentInfo() {
796 if (fViewer == null) {
797 return null;
798 }
799 return fViewer.getTimeViewAlignmentInfo();
800 }
801
802 /**
803 * @since 1.0
804 */
805 @Override
806 public int getAvailableWidth(int requestedOffset) {
807 return fViewer.getAvailableWidth(requestedOffset);
808 }
809
810 /**
811 * @since 1.0
812 */
813 @Override
814 public void performAlign(int offset, int width) {
815 fViewer.performAlign(offset, width);
816 }
6151d86c 817}
Tracecompass - Deliverables
This page took 0.152542 seconds and 5 git commands to generate.