projects / deliverable / tracecompass.git / blob
? search:


dd11e43218fa2b7f19e727ae6d02fb30ba1bc321
[deliverable/tracecompass.git] / org.eclipse.linuxtools.tmf.ui / src / org / eclipse / linuxtools / tmf / ui / widgets / timegraph / widgets / TimeGraphControl.java
1 /*****************************************************************************
2 * Copyright (c) 2007, 2008 Intel Corporation, 2009, 2010, 2011, 2012 Ericsson.
3 * All rights reserved. This program and the accompanying materials
4 * are made available under the terms of the Eclipse Public License v1.0
5 * which accompanies this distribution, and is available at
6 * http://www.eclipse.org/legal/epl-v10.html
7 *
8 * Contributors:
9 * Intel Corporation - Initial API and implementation
10 * Ruslan A. Scherbakov, Intel - Initial API and implementation
11 * Alvaro Sanchez-Leon - Updated for TMF
12 * Patrick Tasse - Refactoring
13 *
14 *****************************************************************************/
15
16 package org.eclipse.linuxtools.tmf.ui.widgets.timegraph.widgets;
17
18 import java.util.ArrayList;
19 import java.util.Iterator;
20 import java.util.List;
21 import java.util.Vector;
22
23 import org.eclipse.jface.resource.JFaceResources;
24 import org.eclipse.jface.resource.LocalResourceManager;
25 import org.eclipse.jface.viewers.ISelection;
26 import org.eclipse.jface.viewers.ISelectionChangedListener;
27 import org.eclipse.jface.viewers.ISelectionProvider;
28 import org.eclipse.linuxtools.tmf.ui.widgets.timegraph.ITimeGraphPresentationProvider;
29 import org.eclipse.linuxtools.tmf.ui.widgets.timegraph.ITimeGraphTreeListener;
30 import org.eclipse.linuxtools.tmf.ui.widgets.timegraph.StateItem;
31 import org.eclipse.linuxtools.tmf.ui.widgets.timegraph.TimeGraphTreeExpansionEvent;
32 import org.eclipse.linuxtools.tmf.ui.widgets.timegraph.model.ITimeEvent;
33 import org.eclipse.linuxtools.tmf.ui.widgets.timegraph.model.ITimeGraphEntry;
34 import org.eclipse.swt.SWT;
35 import org.eclipse.swt.events.ControlEvent;
36 import org.eclipse.swt.events.ControlListener;
37 import org.eclipse.swt.events.FocusEvent;
38 import org.eclipse.swt.events.FocusListener;
39 import org.eclipse.swt.events.KeyEvent;
40 import org.eclipse.swt.events.KeyListener;
41 import org.eclipse.swt.events.MouseEvent;
42 import org.eclipse.swt.events.MouseListener;
43 import org.eclipse.swt.events.MouseMoveListener;
44 import org.eclipse.swt.events.MouseTrackListener;
45 import org.eclipse.swt.events.MouseWheelListener;
46 import org.eclipse.swt.events.PaintEvent;
47 import org.eclipse.swt.events.SelectionEvent;
48 import org.eclipse.swt.events.SelectionListener;
49 import org.eclipse.swt.events.TraverseEvent;
50 import org.eclipse.swt.events.TraverseListener;
51 import org.eclipse.swt.graphics.Color;
52 import org.eclipse.swt.graphics.Cursor;
53 import org.eclipse.swt.graphics.GC;
54 import org.eclipse.swt.graphics.Image;
55 import org.eclipse.swt.graphics.Point;
56 import org.eclipse.swt.graphics.Rectangle;
57 import org.eclipse.swt.widgets.Composite;
58 import org.eclipse.swt.widgets.Display;
59 import org.eclipse.swt.widgets.Event;
60 import org.eclipse.swt.widgets.Listener;
61 import org.eclipse.swt.widgets.ScrollBar;
62
63 /**
64 * Time graph control implementation
65 *
66 * @version 1.0
67 * @author Alvaro Sanchez-Leon
68 * @author Patrick Tasse
69 */
70 public class TimeGraphControl extends TimeGraphBaseControl implements FocusListener, KeyListener, MouseMoveListener, MouseListener, MouseWheelListener, ControlListener, SelectionListener, MouseTrackListener, TraverseListener, ISelectionProvider {
71
72 private static final int DRAG_NONE = 0;
73 private static final int DRAG_TRACE_ITEM = 1;
74 private static final int DRAG_SPLIT_LINE = 2;
75 public static final boolean DEFAULT_DRAW_THREAD_JOIN = true;
76 public static final boolean DEFAULT_DRAW_THREAD_WAIT = true;
77 public static final boolean DEFAULT_DRAW_THREAD_RELEASE = true;
78 public static final int H_SCROLLBAR_MAX = Integer.MAX_VALUE - 1;
79 private static final int CUSTOM_ITEM_HEIGHT = -1; // get item height from provider
80
81 private static final double zoomCoeff = 1.5;
82
83 private ITimeDataProvider _timeProvider;
84 private boolean _isInFocus = false;
85 private boolean _isDragCursor3 = false;
86 private boolean _isWaitCursor = true;
87 private boolean _mouseOverSplitLine = false;
88 private int _itemHeight = CUSTOM_ITEM_HEIGHT;
89 private int _minimumItemWidth = 0;
90 private int _topIndex = 0;
91 private int _dragState = DRAG_NONE;
92 private int _dragX0 = 0;
93 private int _dragX = 0;
94 private int _idealNameSpace = 0;
95 // private double _timeStep = 10000000;
96 private long _time0bak;
97 private long _time1bak;
98 private ITimeGraphPresentationProvider fTimeGraphProvider = null;
99 private ItemData _data = null;
100 private List<SelectionListener> _selectionListeners;
101 private final List<ISelectionChangedListener> _selectionChangedListeners = new ArrayList<ISelectionChangedListener>();
102 private final List<ITimeGraphTreeListener> _treeListeners = new ArrayList<ITimeGraphTreeListener>();
103 private final Cursor _dragCursor3;
104 private final Cursor _WaitCursor;
105
106 // Vertical formatting formatting for the state control view
107 private final boolean _visibleVerticalScroll = true;
108 private int _borderWidth = 0;
109 private int _headerHeight = 0;
110
111 private Listener mouseScrollFilterListener;
112
113 protected LocalResourceManager fResourceManager = new LocalResourceManager(JFaceResources.getResources());
114 protected Color[] fEventColorMap = null;
115
116 private MouseScrollNotifier fMouseScrollNotifier;
117 private final Object fMouseScrollNotifierLock = new Object();
118 private class MouseScrollNotifier extends Thread {
119 private final static long DELAY = 400L;
120 private final static long POLLING_INTERVAL = 10L;
121 private long fLastScrollTime = Long.MAX_VALUE;
122
123 @Override
124 public void run() {
125 while ((System.currentTimeMillis() - fLastScrollTime) < DELAY) {
126 try {
127 Thread.sleep(POLLING_INTERVAL);
128 } catch (Exception e) {
129 return;
130 }
131 }
132 if (!isInterrupted()) {
133 Display.getDefault().asyncExec(new Runnable() {
134 @Override
135 public void run() {
136 if (isDisposed()) {
137 return;
138 }
139 _timeProvider.notifyStartFinishTime();
140 }
141 });
142 }
143 synchronized (fMouseScrollNotifierLock) {
144 fMouseScrollNotifier = null;
145 }
146 }
147
148 public void mouseScrolled() {
149 fLastScrollTime = System.currentTimeMillis();
150 }
151 }
152
153 /**
154 * Standard constructor
155 *
156 * @param parent
157 * The parent composite object
158 * @param colors
159 * The color scheme to use
160 */
161 public TimeGraphControl(Composite parent, TimeGraphColorScheme colors) {
162
163 super(parent, colors, SWT.NO_BACKGROUND | SWT.H_SCROLL | SWT.DOUBLE_BUFFERED);
164
165 _data = new ItemData();
166
167 addFocusListener(this);
168 addMouseListener(this);
169 addMouseMoveListener(this);
170 addMouseTrackListener(this);
171 addMouseWheelListener(this);
172 addTraverseListener(this);
173 addKeyListener(this);
174 addControlListener(this);
175 ScrollBar scrollHor = getHorizontalBar();
176
177 if (scrollHor != null) {
178 scrollHor.addSelectionListener(this);
179 }
180
181 _dragCursor3 = new Cursor(super.getDisplay(), SWT.CURSOR_SIZEWE);
182 _WaitCursor = new Cursor(super.getDisplay(), SWT.CURSOR_WAIT);
183 }
184
185 @Override
186 public void dispose() {
187 super.dispose();
188 _dragCursor3.dispose();
189 _WaitCursor.dispose();
190 fResourceManager.dispose();
191 }
192
193 /**
194 * Sets the timegraph provider used by this timegraph viewer.
195 *
196 * @param timeGraphProvider the timegraph provider
197 */
198 public void setTimeGraphProvider(ITimeGraphPresentationProvider timeGraphProvider) {
199 fTimeGraphProvider = timeGraphProvider;
200 _data.provider = timeGraphProvider;
201
202 if (fEventColorMap != null) {
203 for (Color color : fEventColorMap) {
204 fResourceManager.destroyColor(color.getRGB());
205 }
206 }
207 StateItem[] stateItems = fTimeGraphProvider.getStateTable();
208 if (stateItems != null) {
209 fEventColorMap = new Color[stateItems.length];
210 for (int i = 0; i < stateItems.length; i++) {
211 fEventColorMap[i] = fResourceManager.createColor(stateItems[i].getStateColor());
212 }
213 } else {
214 fEventColorMap = new Color[] { };
215 }
216 }
217
218 /**
219 * Assign the given time provider
220 *
221 * @param timeProvider
222 * The time provider
223 */
224 public void setTimeProvider(ITimeDataProvider timeProvider) {
225 _timeProvider = timeProvider;
226 adjustScrolls();
227 redraw();
228 }
229
230 /**
231 * Add a selection listener
232 *
233 * @param listener
234 * The listener to add
235 */
236 public void addSelectionListener(SelectionListener listener) {
237 if (listener == null) {
238 SWT.error(SWT.ERROR_NULL_ARGUMENT);
239 }
240 if (null == _selectionListeners) {
241 _selectionListeners = new ArrayList<SelectionListener>();
242 }
243 _selectionListeners.add(listener);
244 }
245
246 /**
247 * Remove a selection listener
248 *
249 * @param listener
250 * The listener to remove
251 */
252 public void removeSelectionListener(SelectionListener listener) {
253 if (null != _selectionListeners) {
254 _selectionListeners.remove(listener);
255 }
256 }
257
258 /**
259 * Selection changed callback
260 */
261 public void fireSelectionChanged() {
262 if (null != _selectionListeners) {
263 Iterator<SelectionListener> it = _selectionListeners.iterator();
264 while (it.hasNext()) {
265 SelectionListener listener = it.next();
266 listener.widgetSelected(null);
267 }
268 }
269 }
270
271 /**
272 * Default selection callback
273 */
274 public void fireDefaultSelection() {
275 if (null != _selectionListeners) {
276 Iterator<SelectionListener> it = _selectionListeners.iterator();
277 while (it.hasNext()) {
278 SelectionListener listener = it.next();
279 listener.widgetDefaultSelected(null);
280 }
281 }
282 }
283
284 /**
285 * Get the traces in the model
286 *
287 * @return The array of traces
288 */
289 public ITimeGraphEntry[] getTraces() {
290 return _data.getTraces();
291 }
292
293 /**
294 * Get the on/off trace filters
295 *
296 * @return The array of filters
297 */
298 public boolean[] getTraceFilter() {
299 return _data.getTraceFilter();
300 }
301
302 /**
303 * Refresh the data for the thing
304 */
305 public void refreshData() {
306 _data.refreshData();
307 adjustScrolls();
308 redraw();
309 }
310
311 /**
312 * Refresh data for the given traces
313 *
314 * @param traces
315 * The traces to refresh
316 */
317 public void refreshData(ITimeGraphEntry[] traces) {
318 _data.refreshData(traces);
319 adjustScrolls();
320 redraw();
321 }
322
323 /**
324 * Adjust the scoll bars
325 */
326 public void adjustScrolls() {
327 if (null == _timeProvider) {
328 getHorizontalBar().setValues(0, 1, 1, 1, 1, 1);
329 return;
330 }
331
332 // HORIZONTAL BAR
333 // Visible window
334 long time0 = _timeProvider.getTime0();
335 long time1 = _timeProvider.getTime1();
336 // Time boundaries
337 long timeMin = _timeProvider.getMinTime();
338 long timeMax = _timeProvider.getMaxTime();
339
340 long delta = timeMax - timeMin;
341
342 int timePos = 0;
343 int thumb = H_SCROLLBAR_MAX;
344
345 if (delta != 0) {
346 // Thumb size (page size)
347 thumb = Math.max(1, (int) (H_SCROLLBAR_MAX * ((double) (time1 - time0) / delta)));
348 // At the beginning of visible window
349 timePos = (int) (H_SCROLLBAR_MAX * ((double) (time0 - timeMin) / delta));
350 }
351
352 // position, minimum, maximum, thumb size, increment (half page)t, page
353 // increment size (full page)
354 getHorizontalBar().setValues(timePos, 0, H_SCROLLBAR_MAX, thumb, Math.max(1, thumb / 2), Math.max(2, thumb));
355 }
356
357 boolean ensureVisibleItem(int idx, boolean redraw) {
358 boolean changed = false;
359 if (idx < 0) {
360 for (idx = 0; idx < _data._expandedItems.length; idx++) {
361 if (_data._expandedItems[idx]._selected) {
362 break;
363 }
364 }
365 }
366 if (idx >= _data._expandedItems.length) {
367 return changed;
368 }
369 if (idx < _topIndex) {
370 setTopIndex(idx);
371 //FIXME:getVerticalBar().setSelection(_topItem);
372 if (redraw) {
373 redraw();
374 }
375 changed = true;
376 } else {
377 int page = countPerPage();
378 if (idx >= _topIndex + page) {
379 setTopIndex(idx - page + 1);
380 //FIXME:getVerticalBar().setSelection(_topItem);
381 if (redraw) {
382 redraw();
383 }
384 changed = true;
385 }
386 }
387 return changed;
388 }
389
390 /**
391 * Assign the given index as the top one
392 *
393 * @param idx
394 * The index
395 */
396 public void setTopIndex(int idx) {
397 idx = Math.min(idx, _data._expandedItems.length - countPerPage());
398 idx = Math.max(0, idx);
399 _topIndex = idx;
400 redraw();
401 }
402
403 /**
404 * Set the expanded state of a given entry
405 *
406 * @param entry
407 * The entry
408 * @param expanded
409 * True if expanded, false if collapsed
410 */
411 public void setExpandedState(ITimeGraphEntry entry, boolean expanded) {
412 Item item = _data.findItem(entry);
413 if (item != null && item._expanded != expanded) {
414 item._expanded = expanded;
415 _data.updateExpandedItems();
416 redraw();
417 }
418 }
419
420 /**
421 * Add a tree listener
422 *
423 * @param listener
424 * The listener to add
425 */
426 public void addTreeListener(ITimeGraphTreeListener listener) {
427 if (!_treeListeners.contains(listener)) {
428 _treeListeners.add(listener);
429 }
430 }
431
432 /**
433 * Remove a tree listener
434 *
435 * @param listener
436 * The listener to remove
437 */
438 public void removeTreeListener(ITimeGraphTreeListener listener) {
439 if (_treeListeners.contains(listener)) {
440 _treeListeners.remove(listener);
441 }
442 }
443
444 /**
445 * Tree event callback
446 *
447 * @param entry
448 * The affected entry
449 * @param expanded
450 * The expanded state (true for expanded, false for collapsed)
451 */
452 public void fireTreeEvent(ITimeGraphEntry entry, boolean expanded) {
453 TimeGraphTreeExpansionEvent event = new TimeGraphTreeExpansionEvent(this, entry);
454 for (ITimeGraphTreeListener listener : _treeListeners) {
455 if (expanded) {
456 listener.treeExpanded(event);
457 } else {
458 listener.treeCollapsed(event);
459 }
460 }
461 }
462
463 @Override
464 public ISelection getSelection() {
465 TimeGraphSelection sel = new TimeGraphSelection();
466 ITimeGraphEntry trace = getSelectedTrace();
467 if (null != trace && null != _timeProvider) {
468 long selectedTime = _timeProvider.getSelectedTime();
469 ITimeEvent event = Utils.findEvent(trace, selectedTime, 0);
470 if (event != null) {
471 sel.add(event);
472 } else {
473 sel.add(trace);
474 }
475 }
476 return sel;
477 }
478
479 /**
480 * Get the selection object
481 *
482 * @return The selection
483 */
484 public ISelection getSelectionTrace() {
485 TimeGraphSelection sel = new TimeGraphSelection();
486 ITimeGraphEntry trace = getSelectedTrace();
487 if (null != trace) {
488 sel.add(trace);
489 }
490 return sel;
491 }
492
493
494 // TODO select implementation for selectTrace
495 // public void selectTrace(int n) {
496 // if (n != 1 && n != -1)
497 // return;
498 // boolean changed = false;
499 // int lastSelection = -1;
500 // for (int i = 0; i < _data._expandedItems.length; i++) {
501 // TimeGraphItem item = (TimeGraphItem) _data._expandedItems[i];
502 // if (item._selected) {
503 // lastSelection = i;
504 // if (1 == n && i < _data._expandedItems.length - 1) {
505 // item._selected = false;
506 // if (item._hasChildren) {
507 // _data.expandItem(i);
508 // fireTreeEvent(item._trace, item._expanded);
509 // }
510 // item = (TimeGraphItem) _data._expandedItems[i + 1];
511 // if (item._hasChildren) {
512 // _data.expandItem(i + 1);
513 // fireTreeEvent(item._trace, item._expanded);
514 // item = (TimeGraphItem) _data._expandedItems[i + 2];
515 // }
516 // item._selected = true;
517 // changed = true;
518 // } else if (-1 == n && i > 0) {
519 // i--;
520 // TimeGraphItem prevItem = (TimeGraphItem) _data._expandedItems[i];
521 // if (prevItem._hasChildren) {
522 // if (prevItem._expanded) {
523 // if (i > 0) {
524 // i--;
525 // prevItem = (TimeGraphItem) _data._expandedItems[i];
526 // }
527 // }
528 // if (!prevItem._expanded) {
529 // _data.expandItem(i);
530 // fireTreeEvent(prevItem._trace, prevItem._expanded);
531 // prevItem = (TimeGraphItem) _data._expandedItems[i + prevItem.children.size()];
532 // item._selected = false;
533 // prevItem._selected = true;
534 // changed = true;
535 // }
536 // } else {
537 // item._selected = false;
538 // prevItem._selected = true;
539 // changed = true;
540 // }
541 // }
542 // break;
543 // }
544 // }
545 // if (lastSelection < 0 && _data._expandedItems.length > 0) {
546 // TimeGraphItem item = (TimeGraphItem) _data._expandedItems[0];
547 // if (item._hasChildren) {
548 // _data.expandItem(0);
549 // fireTreeEvent(item._trace, item._expanded);
550 // item = (TimeGraphItem) _data._expandedItems[1];
551 // item._selected = true;
552 // changed = true;
553 // } else {
554 // item._selected = true;
555 // changed = true;
556 // }
557 // }
558 // if (changed) {
559 // ensureVisibleItem(-1, false);
560 // redraw();
561 // fireSelectionChanged();
562 // }
563 // }
564
565 /**
566 * Enable/disable one of the traces in the model
567 *
568 * @param n
569 * 1 to enable it, -1 to disable. The method returns immediately
570 * if another value is used.
571 */
572 public void selectTrace(int n) {
573 if ((n != 1) && (n != -1)) {
574 return;
575 }
576
577 boolean changed = false;
578 int lastSelection = -1;
579 for (int i = 0; i < _data._expandedItems.length; i++) {
580 Item item = _data._expandedItems[i];
581 if (item._selected) {
582 lastSelection = i;
583 if ((1 == n) && (i < _data._expandedItems.length - 1)) {
584 item._selected = false;
585 item = _data._expandedItems[i + 1];
586 item._selected = true;
587 changed = true;
588 } else if ((-1 == n) && (i > 0)) {
589 item._selected = false;
590 item = _data._expandedItems[i - 1];
591 item._selected = true;
592 changed = true;
593 }
594 break;
595 }
596 }
597
598 if (lastSelection < 0 && _data._expandedItems.length > 0) {
599 Item item = _data._expandedItems[0];
600 item._selected = true;
601 changed = true;
602 }
603
604 if (changed) {
605 ensureVisibleItem(-1, false);
606 redraw();
607 fireSelectionChanged();
608 }
609 }
610
611 /**
612 * Select an event
613 *
614 * @param n
615 * 1 to enable, -1 to disable
616 */
617 public void selectEvent(int n) {
618 if (null == _timeProvider) {
619 return;
620 }
621 ITimeGraphEntry trace = getSelectedTrace();
622 if (trace == null) {
623 return;
624 }
625 long selectedTime = _timeProvider.getSelectedTime();
626 long endTime = _timeProvider.getEndTime();
627 ITimeEvent nextEvent;
628 if (-1 == n && selectedTime > endTime) {
629 nextEvent = Utils.findEvent(trace, selectedTime, 0);
630 } else {
631 nextEvent = Utils.findEvent(trace, selectedTime, n);
632 }
633 if (null == nextEvent && -1 == n) {
634 nextEvent = Utils.getFirstEvent(trace);
635 }
636 if (null != nextEvent) {
637 long nextTime = nextEvent.getTime();
638 // If last event detected e.g. going back or not moving to a next
639 // event
640 if (nextTime <= selectedTime && n == 1) {
641 // Select to the end of this last event
642 nextTime = nextEvent.getTime() + nextEvent.getDuration();
643 // but not beyond the end of the trace
644 if (nextTime > endTime) {
645 nextTime = endTime;
646 }
647 }
648 _timeProvider.setSelectedTimeNotify(nextTime, true);
649 fireSelectionChanged();
650 } else if (1 == n) {
651 _timeProvider.setSelectedTimeNotify(endTime, true);
652 fireSelectionChanged();
653 }
654 }
655
656 /**
657 * Select the next event
658 */
659 public void selectNextEvent() {
660 selectEvent(1);
661 // Notify if visible time window has been adjusted
662 _timeProvider.setStartFinishTimeNotify(_timeProvider.getTime0(), _timeProvider.getTime1());
663 }
664
665 /**
666 * Select the previous event
667 */
668 public void selectPrevEvent() {
669 selectEvent(-1);
670 // Notify if visible time window has been adjusted
671 _timeProvider.setStartFinishTimeNotify(_timeProvider.getTime0(), _timeProvider.getTime1());
672 }
673
674 /**
675 * Select the next trace
676 */
677 public void selectNextTrace() {
678 selectTrace(1);
679 }
680
681 /**
682 * Select the previous trace
683 */
684 public void selectPrevTrace() {
685 selectTrace(-1);
686 }
687
688 /**
689 * Zoom based on mouse cursor location with mouse scrolling
690 *
691 * @param zoomIn true to zoom in, false to zoom out
692 */
693 public void zoom(boolean zoomIn) {
694 int globalX = getDisplay().getCursorLocation().x;
695 Point p = toControl(globalX, 0);
696 int nameSpace = _timeProvider.getNameSpace();
697 int timeSpace = _timeProvider.getTimeSpace();
698 int xPos = Math.max(nameSpace, Math.min(nameSpace + timeSpace, p.x));
699 long time0 = _timeProvider.getTime0();
700 long time1 = _timeProvider.getTime1();
701 long interval = time1 - time0;
702 if (interval == 0) {
703 interval = 1;
704 } // to allow getting out of single point interval
705 long newInterval;
706 if (zoomIn) {
707 newInterval = Math.max(Math.round(interval * 0.8), _timeProvider.getMinTimeInterval());
708 } else {
709 newInterval = (long) Math.ceil(interval * 1.25);
710 }
711 long center = time0 + Math.round(((double) (xPos - nameSpace) / timeSpace * interval));
712 long newTime0 = center - Math.round((double) newInterval * (center - time0) / interval);
713 long newTime1 = newTime0 + newInterval;
714 _timeProvider.setStartFinishTime(newTime0, newTime1);
715 synchronized (fMouseScrollNotifierLock) {
716 if (fMouseScrollNotifier == null) {
717 fMouseScrollNotifier = new MouseScrollNotifier();
718 fMouseScrollNotifier.start();
719 }
720 fMouseScrollNotifier.mouseScrolled();
721 }
722 }
723
724 /**
725 * zoom in using single click
726 */
727 public void zoomIn() {
728 long _time0 = _timeProvider.getTime0();
729 long _time1 = _timeProvider.getTime1();
730 long _range = _time1 - _time0;
731 long selTime = _timeProvider.getSelectedTime();
732 if (selTime <= _time0 || selTime >= _time1) {
733 selTime = (_time0 + _time1) / 2;
734 }
735 long time0 = selTime - (long) ((selTime - _time0) / zoomCoeff);
736 long time1 = selTime + (long) ((_time1 - selTime) / zoomCoeff);
737
738 long inaccuracy = (_timeProvider.getMaxTime() - _timeProvider.getMinTime()) - (time1 - time0);
739
740 // Trace.debug("selTime:" + selTime + " time0:" + time0 + " time1:"
741 // + time1 + " inaccuracy:" + inaccuracy);
742
743 if (inaccuracy > 0 && inaccuracy < 100) {
744 _timeProvider.setStartFinishTimeNotify(_timeProvider.getMinTime(), _timeProvider.getMaxTime());
745 return;
746 }
747
748 long m = _timeProvider.getMinTimeInterval();
749 if ((time1 - time0) < m) {
750 time0 = selTime - (selTime - _time0) * m / _range;
751 time1 = time0 + m;
752 }
753
754 _timeProvider.setStartFinishTimeNotify(time0, time1);
755 }
756
757 /**
758 * zoom out using single click
759 */
760 public void zoomOut() {
761 long _time0 = _timeProvider.getTime0();
762 long _time1 = _timeProvider.getTime1();
763 long selTime = _timeProvider.getSelectedTime();
764 if (selTime <= _time0 || selTime >= _time1) {
765 selTime = (_time0 + _time1) / 2;
766 }
767 long time0 = (long) (selTime - (selTime - _time0) * zoomCoeff);
768 long time1 = (long) (selTime + (_time1 - selTime) * zoomCoeff);
769
770 long inaccuracy = (_timeProvider.getMaxTime() - _timeProvider.getMinTime()) - (time1 - time0);
771 if (inaccuracy > 0 && inaccuracy < 100) {
772 _timeProvider.setStartFinishTimeNotify(_timeProvider.getMinTime(), _timeProvider.getMaxTime());
773 return;
774 }
775
776 _timeProvider.setStartFinishTimeNotify(time0, time1);
777 }
778
779 /**
780 * Return the currently selected trace
781 *
782 * @return The entry matching the trace
783 */
784 public ITimeGraphEntry getSelectedTrace() {
785 ITimeGraphEntry trace = null;
786 int idx = getSelectedIndex();
787 if (idx >= 0) {
788 trace = _data._expandedItems[idx]._trace;
789 }
790 return trace;
791 }
792
793 /**
794 * Retrieve the index of the currently selected item
795 *
796 * @return The index
797 */
798 public int getSelectedIndex() {
799 int idx = -1;
800 for (int i = 0; i < _data._expandedItems.length; i++) {
801 Item item = _data._expandedItems[i];
802 if (item._selected) {
803 idx = i;
804 break;
805 }
806 }
807 return idx;
808 }
809
810 boolean toggle(int idx) {
811 boolean toggled = false;
812 if (idx >= 0 && idx < _data._expandedItems.length) {
813 Item item = _data._expandedItems[idx];
814 if (item._hasChildren) {
815 item._expanded = !item._expanded;
816 _data.updateExpandedItems();
817 adjustScrolls();
818 redraw();
819 toggled = true;
820 fireTreeEvent(item._trace, item._expanded);
821 }
822 }
823 return toggled;
824 }
825
826 int getItemIndexAtY(int y) {
827 if (y < 0) {
828 return -1;
829 }
830 if (_itemHeight == CUSTOM_ITEM_HEIGHT) {
831 int ySum = 0;
832 for (int idx = _topIndex; idx < _data._expandedItems.length; idx++) {
833 ySum += _data._expandedItems[idx].itemHeight;
834 if (y < ySum) {
835 return idx;
836 }
837 }
838 return -1;
839 }
840 int idx = y / _itemHeight;
841 idx += _topIndex;
842 if (idx < _data._expandedItems.length) {
843 return idx;
844 }
845 return -1;
846 }
847
848 boolean isOverSplitLine(int x) {
849 if (x < 0 || null == _timeProvider) {
850 return false;
851 }
852 int w = 4;
853 int nameWidth = _timeProvider.getNameSpace();
854 if (x > nameWidth - w && x < nameWidth + w) {
855 return true;
856 }
857 return false;
858 }
859
860 ITimeGraphEntry getEntry(Point pt) {
861 int idx = getItemIndexAtY(pt.y);
862 return idx >= 0 ? _data._expandedItems[idx]._trace : null;
863 }
864
865 long getTimeAtX(int x) {
866 if (null == _timeProvider) {
867 return -1;
868 }
869 long hitTime = -1;
870 Point size = getCtrlSize();
871 long time0 = _timeProvider.getTime0();
872 long time1 = _timeProvider.getTime1();
873 int nameWidth = _timeProvider.getNameSpace();
874 x -= nameWidth;
875 int timeWidth = size.x - nameWidth - RIGHT_MARGIN;
876 if (x >= 0 && size.x >= nameWidth) {
877 if (time1 - time0 > timeWidth) {
878 // get the last possible time represented by the pixel position
879 // by taking the time of the next pixel position minus 1 nanosecond
880 hitTime = time0 + (long) ((time1 - time0) * ((double) (x + 1) / timeWidth)) - 1;
881 } else {
882 hitTime = time0 + Math.round((time1 - time0) * ((double) x / timeWidth));
883 }
884 }
885 return hitTime;
886 }
887
888 void selectItem(int idx, boolean addSelection) {
889 boolean changed = false;
890 if (addSelection) {
891 if (idx >= 0 && idx < _data._expandedItems.length) {
892 Item item = _data._expandedItems[idx];
893 changed = (item._selected == false);
894 item._selected = true;
895 }
896 } else {
897 for (int i = 0; i < _data._expandedItems.length; i++) {
898 Item item = _data._expandedItems[i];
899 if ((i == idx && !item._selected) || (idx == -1 && item._selected)) {
900 changed = true;
901 }
902 item._selected = i == idx;
903 }
904 }
905 changed |= ensureVisibleItem(idx, true);
906 if (changed) {
907 redraw();
908 }
909 }
910
911 /**
912 * Callback for item selection
913 *
914 * @param trace
915 * The entry matching the trace
916 * @param addSelection
917 * If the selection is added or removed
918 */
919 public void selectItem(ITimeGraphEntry trace, boolean addSelection) {
920 int idx = _data.findItemIndex(trace);
921 selectItem(idx, addSelection);
922 }
923
924 /**
925 * Retrieve the number of entries shown per page.
926 *
927 * @return The count
928 */
929 public int countPerPage() {
930 int height = getCtrlSize().y;
931 int count = 0;
932 if (_itemHeight == CUSTOM_ITEM_HEIGHT) {
933 int ySum = 0;
934 for (int idx = _topIndex; idx < _data._expandedItems.length; idx++) {
935 ySum += _data._expandedItems[idx].itemHeight;
936 if (ySum >= height) {
937 return count;
938 }
939 count++;
940 }
941 for (int idx = _topIndex - 1; idx >= 0; idx--) {
942 ySum += _data._expandedItems[idx].itemHeight;
943 if (ySum >= height) {
944 return count;
945 }
946 count++;
947 }
948 return count;
949 }
950 if (height > 0) {
951 count = height / _itemHeight;
952 }
953 return count;
954 }
955
956 /**
957 * Get the index of the top element
958 *
959 * @return The index
960 */
961 public int getTopIndex() {
962 return _topIndex;
963 }
964
965 /**
966 * Get the number of expanded items
967 *
968 * @return The count of expanded items
969 */
970 public int getExpandedElementCount() {
971 return _data._expandedItems.length;
972 }
973
974 /**
975 * Get an array of all expanded elements
976 *
977 * @return The expanded elements
978 */
979 public ITimeGraphEntry[] getExpandedElements() {
980 ArrayList<ITimeGraphEntry> elements = new ArrayList<ITimeGraphEntry>();
981 for (Item item : _data._expandedItems) {
982 elements.add(item._trace);
983 }
984 return elements.toArray(new ITimeGraphEntry[0]);
985 }
986
987 Point getCtrlSize() {
988 Point size = getSize();
989 if (getHorizontalBar().isVisible()) {
990 size.y -= getHorizontalBar().getSize().y;
991 }
992 return size;
993 }
994
995 Rectangle getNameRect(Rectangle bound, int idx, int nameWidth) {
996 int x = bound.x;
997 int y = bound.y + (idx - _topIndex) * _itemHeight;
998 int width = nameWidth;
999 int height = _itemHeight;
1000 if (_itemHeight == CUSTOM_ITEM_HEIGHT) {
1001 int ySum = 0;
1002 for (int i = _topIndex; i < idx; i++) {
1003 ySum += _data._expandedItems[i].itemHeight;
1004 }
1005 y = bound.y + ySum;
1006 height = _data._expandedItems[idx].itemHeight;
1007 }
1008 return new Rectangle(x, y, width, height);
1009 }
1010
1011 Rectangle getStatesRect(Rectangle bound, int idx, int nameWidth) {
1012 int x = bound.x + nameWidth;
1013 int y = bound.y + (idx - _topIndex) * _itemHeight;
1014 int width = bound.width - x;
1015 int height = _itemHeight;
1016 if (_itemHeight == CUSTOM_ITEM_HEIGHT) {
1017 int ySum = 0;
1018 for (int i = _topIndex; i < idx; i++) {
1019 ySum += _data._expandedItems[i].itemHeight;
1020 }
1021 y = bound.y + ySum;
1022 height = _data._expandedItems[idx].itemHeight;
1023 }
1024 return new Rectangle(x, y, width, height);
1025 }
1026
1027 @Override
1028 void paint(Rectangle bounds, PaintEvent e) {
1029 GC gc = e.gc;
1030 gc.setBackground(_colors.getColor(TimeGraphColorScheme.BACKGROUND));
1031 drawBackground(gc, bounds.x, bounds.y, bounds.width, bounds.height);
1032
1033 if (bounds.width < 2 || bounds.height < 2 || null == _timeProvider) {
1034 return;
1035 }
1036
1037 _idealNameSpace = 0;
1038 int nameSpace = _timeProvider.getNameSpace();
1039
1040 // draw empty name space background
1041 gc.setBackground(_colors.getBkColor(false, false, true));
1042 drawBackground(gc, bounds.x, bounds.y, nameSpace, bounds.height);
1043
1044 drawItems(bounds, _timeProvider, _data._expandedItems, _topIndex, nameSpace, gc);
1045
1046 // draw selected time
1047 long time0 = _timeProvider.getTime0();
1048 long time1 = _timeProvider.getTime1();
1049 long selectedTime = _timeProvider.getSelectedTime();
1050 double pixelsPerNanoSec = (bounds.width - nameSpace <= RIGHT_MARGIN) ? 0 : (double) (bounds.width - nameSpace - RIGHT_MARGIN) / (time1 - time0);
1051 int x = bounds.x + nameSpace + (int) ((selectedTime - time0) * pixelsPerNanoSec);
1052 if (x >= nameSpace && x < bounds.x + bounds.width) {
1053 gc.setForeground(_colors.getColor(TimeGraphColorScheme.SELECTED_TIME));
1054 gc.drawLine(x, bounds.y, x, bounds.y + bounds.height);
1055 }
1056
1057 // draw drag line, no line if name space is 0.
1058 if (DRAG_SPLIT_LINE == _dragState) {
1059 gc.setForeground(_colors.getColor(TimeGraphColorScheme.BLACK));
1060 gc.drawLine(bounds.x + nameSpace, bounds.y, bounds.x + nameSpace, bounds.y + bounds.height - 1);
1061 } else if (DRAG_NONE == _dragState && _mouseOverSplitLine && _timeProvider.getNameSpace() > 0) {
1062 gc.setForeground(_colors.getColor(TimeGraphColorScheme.RED));
1063 gc.drawLine(bounds.x + nameSpace, bounds.y, bounds.x + nameSpace, bounds.y + bounds.height - 1);
1064 }
1065 }
1066
1067 /**
1068 * Draw many items at once
1069 *
1070 * @param bounds
1071 * The rectangle of the area
1072 * @param timeProvider
1073 * The time provider
1074 * @param items
1075 * The array items to draw
1076 * @param topIndex
1077 * The index of the first element to draw
1078 * @param nameSpace
1079 * The width reserved for the names
1080 * @param gc
1081 * Reference to the SWT GC object
1082 */
1083 public void drawItems(Rectangle bounds, ITimeDataProvider timeProvider,
1084 Item[] items, int topIndex, int nameSpace, GC gc) {
1085 for (int i = topIndex; i < items.length; i++) {
1086 Item item = items[i];
1087 drawItem(item, bounds, timeProvider, i, nameSpace, gc);
1088 }
1089 fTimeGraphProvider.postDrawControl(bounds, gc);
1090 }
1091
1092 /**
1093 * Draws the item
1094 *
1095 * @param item the item to draw
1096 * @param bounds the container rectangle
1097 * @param i the item index
1098 * @param nameSpace the name space
1099 * @param gc
1100 */
1101 protected void drawItem(Item item, Rectangle bounds, ITimeDataProvider timeProvider, int i, int nameSpace, GC gc) {
1102 ITimeGraphEntry entry = item._trace;
1103 long time0 = timeProvider.getTime0();
1104 long time1 = timeProvider.getTime1();
1105 long selectedTime = timeProvider.getSelectedTime();
1106
1107 Rectangle nameRect = getNameRect(bounds, i, nameSpace);
1108 if (nameRect.y >= bounds.y + bounds.height) {
1109 return;
1110 }
1111
1112 if (! item._trace.hasTimeEvents()) {
1113 Rectangle statesRect = getStatesRect(bounds, i, nameSpace);
1114 nameRect.width += statesRect.width;
1115 drawName(item, nameRect, gc);
1116 } else {
1117 drawName(item, nameRect, gc);
1118 }
1119 Rectangle rect = getStatesRect(bounds, i, nameSpace);
1120 if (rect.isEmpty()) {
1121 fTimeGraphProvider.postDrawEntry(entry, rect, gc);
1122 return;
1123 }
1124 if (time1 <= time0) {
1125 gc.setBackground(_colors.getBkColor(false, false, false));
1126 gc.fillRectangle(rect);
1127 fTimeGraphProvider.postDrawEntry(entry, rect, gc);
1128 return;
1129 }
1130
1131 // Initialize _rect1 to same values as enclosing rectangle rect
1132 Rectangle stateRect = Utils.clone(rect);
1133 boolean selected = item._selected;
1134 // K pixels per second
1135 double pixelsPerNanoSec = (rect.width <= RIGHT_MARGIN) ? 0 : (double) (rect.width - RIGHT_MARGIN) / (time1 - time0);
1136
1137 if (item._trace.hasTimeEvents()) {
1138 fillSpace(rect, gc, selected);
1139 // Drawing rectangle is smaller than reserved space
1140 stateRect.y += 3;
1141 stateRect.height -= 6;
1142
1143 long maxDuration = (timeProvider.getTimeSpace() == 0) ? Long.MAX_VALUE : 1 * (time1 - time0) / timeProvider.getTimeSpace();
1144 Iterator<ITimeEvent> iterator = entry.getTimeEventsIterator(time0, time1, maxDuration);
1145
1146 int lastX = -1;
1147 while (iterator.hasNext()) {
1148 ITimeEvent event = iterator.next();
1149 int x = rect.x + (int) ((event.getTime() - time0) * pixelsPerNanoSec);
1150 int xEnd = rect.x + (int) ((event.getTime() + event.getDuration() - time0) * pixelsPerNanoSec);
1151 if (x >= rect.x + rect.width || xEnd < rect.x) {
1152 // event is out of bounds
1153 continue;
1154 }
1155 xEnd = Math.min(rect.x + rect.width, xEnd);
1156 stateRect.x = Math.max(rect.x, x);
1157 stateRect.width = Math.max(0, xEnd - stateRect.x + 1);
1158 if (stateRect.x == lastX) {
1159 stateRect.width -= 1;
1160 if (stateRect.width > 0) {
1161 gc.setForeground(Display.getDefault().getSystemColor(SWT.COLOR_BLACK));
1162 gc.drawPoint(stateRect.x, stateRect.y - 2);
1163 stateRect.x += 1;
1164 }
1165 } else {
1166 lastX = x;
1167 }
1168 boolean timeSelected = selectedTime >= event.getTime() && selectedTime < event.getTime() + event.getDuration();
1169 drawState(_colors, event, stateRect, gc, selected, timeSelected);
1170 }
1171 }
1172 fTimeGraphProvider.postDrawEntry(entry, rect, gc);
1173 }
1174
1175 protected void drawName(Item item, Rectangle bounds, GC gc) {
1176 boolean hasTimeEvents = item._trace.hasTimeEvents();
1177 if (! hasTimeEvents) {
1178 gc.setBackground(_colors.getBkColorGroup(item._selected, _isInFocus));
1179 gc.fillRectangle(bounds);
1180 if (item._selected && _isInFocus) {
1181 gc.setForeground(_colors.getBkColor(item._selected, _isInFocus, false));
1182 gc.drawRectangle(bounds.x, bounds.y, bounds.width - 1, bounds.height - 1);
1183 }
1184 } else {
1185 gc.setBackground(_colors.getBkColor(item._selected, _isInFocus, true));
1186 gc.setForeground(_colors.getFgColor(item._selected, _isInFocus));
1187 gc.fillRectangle(bounds);
1188 }
1189
1190 // No name to be drawn
1191 if (_timeProvider.getNameSpace() == 0) {
1192 return;
1193 }
1194
1195 int leftMargin = MARGIN + item.level * EXPAND_SIZE;
1196 if (item._hasChildren) {
1197 gc.setForeground(_colors.getFgColorGroup(false, false));
1198 gc.setBackground(_colors.getBkColor(false, false, false));
1199 Rectangle rect = Utils.clone(bounds);
1200 rect.x += leftMargin;
1201 rect.y += (bounds.height - EXPAND_SIZE) / 2;
1202 rect.width = EXPAND_SIZE;
1203 rect.height = EXPAND_SIZE;
1204 gc.fillRectangle(rect);
1205 gc.drawRectangle(rect.x, rect.y, rect.width - 1, rect.height - 1);
1206 int midy = rect.y + rect.height / 2;
1207 gc.drawLine(rect.x + 2, midy, rect.x + rect.width - 3, midy);
1208 if (!item._expanded) {
1209 int midx = rect.x + rect.width / 2;
1210 gc.drawLine(midx, rect.y + 2, midx, rect.y + rect.height - 3);
1211 }
1212 }
1213 leftMargin += EXPAND_SIZE + MARGIN;
1214
1215 Image img = fTimeGraphProvider.getItemImage(item._trace);
1216 if (img != null) {
1217 // draw icon
1218 int imgHeight = img.getImageData().height;
1219 int imgWidth = img.getImageData().width;
1220 int x = leftMargin;
1221 int y = bounds.y + (bounds.height - imgHeight) / 2;
1222 gc.drawImage(img, x, y);
1223 leftMargin += imgWidth + MARGIN;
1224 }
1225 String name = item._name;
1226 Point size = gc.stringExtent(name);
1227 if (_idealNameSpace < leftMargin + size.x + MARGIN) {
1228 _idealNameSpace = leftMargin + size.x + MARGIN;
1229 }
1230 if (hasTimeEvents) {
1231 // cut long string with "..."
1232 int width = bounds.width - leftMargin;
1233 int cuts = 0;
1234 while (size.x > width && name.length() > 1) {
1235 cuts++;
1236 name = name.substring(0, name.length() - 1);
1237 size = gc.stringExtent(name + "..."); //$NON-NLS-1$
1238 }
1239 if (cuts > 0) {
1240 name += "..."; //$NON-NLS-1$
1241 }
1242 }
1243 Rectangle rect = Utils.clone(bounds);
1244 rect.x += leftMargin;
1245 rect.width -= leftMargin;
1246 // draw text
1247 if (rect.width > 0) {
1248 rect.y += (bounds.height - gc.stringExtent(name).y) / 2;
1249 gc.setForeground(_colors.getFgColor(item._selected, _isInFocus));
1250 int textWidth = Utils.drawText(gc, name, rect, true);
1251 leftMargin += textWidth + MARGIN;
1252 rect.y -= 2;
1253
1254 if (hasTimeEvents) {
1255 // draw middle line
1256 int x = bounds.x + leftMargin;
1257 int width = bounds.width - x;
1258 int midy = bounds.y + bounds.height / 2;
1259 gc.setForeground(_colors.getColor(TimeGraphColorScheme.MID_LINE));
1260 gc.drawLine(x, midy, x + width, midy);
1261 }
1262 }
1263 }
1264
1265 protected void drawState(TimeGraphColorScheme colors, ITimeEvent event,
1266 Rectangle rect, GC gc, boolean selected, boolean timeSelected) {
1267
1268 int colorIdx = fTimeGraphProvider.getStateTableIndex(event);
1269 if (colorIdx < 0) {
1270 return;
1271 }
1272 boolean visible = rect.width == 0 ? false : true;
1273
1274 if (visible) {
1275 Color stateColor = null;
1276 if (colorIdx < fEventColorMap.length) {
1277 stateColor = fEventColorMap[colorIdx];
1278 } else {
1279 stateColor = Display.getDefault().getSystemColor(SWT.COLOR_BLACK);
1280 }
1281
1282 timeSelected = timeSelected && selected;
1283 if (timeSelected) {
1284 // modify the color?
1285 }
1286 // fill all rect area
1287 gc.setBackground(stateColor);
1288 gc.fillRectangle(rect);
1289 // get the border color?
1290 gc.setForeground(Display.getDefault().getSystemColor(SWT.COLOR_BLACK));
1291
1292 // draw bounds
1293 if (!timeSelected) {
1294 // Draw the top and bottom borders i.e. no side borders
1295 // top
1296 gc.drawLine(rect.x, rect.y, rect.x + rect.width - 1, rect.y);
1297 // bottom
1298 gc.drawLine(rect.x, rect.y + rect.height - 1, rect.x + rect.width - 1, rect.y + rect.height - 1);
1299 }
1300 } else {
1301 gc.setForeground(Display.getDefault().getSystemColor(SWT.COLOR_BLACK));
1302 gc.drawPoint(rect.x, rect.y - 2);
1303 /*
1304 // selected rectangle area is not visible but can be represented
1305 // with a broken vertical line of specified width.
1306 int width = 1;
1307 rect.width = width;
1308 gc.setForeground(stateColor);
1309 int s = gc.getLineStyle();
1310 int w = gc.getLineWidth();
1311 gc.setLineStyle(SWT.LINE_DOT);
1312 gc.setLineWidth(width);
1313 // Trace.debug("Rectangle not visible, drawing vertical line with: "
1314 // + rect.x + "," + rect.y + "," + rect.x + "," + rect.y
1315 // + rect.height);
1316 gc.drawLine(rect.x, rect.y, rect.x, rect.y + rect.height - 1);
1317 gc.setLineStyle(s);
1318 gc.setLineWidth(w);
1319 if (!timeSelected) {
1320 gc.setForeground(Display.getDefault().getSystemColor(SWT.COLOR_BLACK));
1321 gc.drawPoint(rect.x, rect.y);
1322 gc.drawPoint(rect.x, rect.y + rect.height - 1);
1323 }
1324 */
1325 }
1326 fTimeGraphProvider.postDrawEvent(event, rect, gc);
1327 }
1328
1329 protected void fillSpace(Rectangle rect, GC gc, boolean selected) {
1330 gc.setBackground(_colors.getBkColor(selected, _isInFocus, false));
1331 gc.fillRectangle(rect);
1332 // draw middle line
1333 gc.setForeground(_colors.getColor(TimeGraphColorScheme.MID_LINE));
1334 int midy = rect.y + rect.height / 2;
1335 gc.drawLine(rect.x, midy, rect.x + rect.width, midy);
1336 }
1337
1338 @Override
1339 public void keyTraversed(TraverseEvent e) {
1340 if ((e.detail == SWT.TRAVERSE_TAB_NEXT) || (e.detail == SWT.TRAVERSE_TAB_PREVIOUS)) {
1341 e.doit = true;
1342 }
1343 }
1344
1345 @Override
1346 public void keyPressed(KeyEvent e) {
1347 int idx = -1;
1348 if (_data._expandedItems.length == 0) {
1349 return;
1350 }
1351 if (SWT.HOME == e.keyCode) {
1352 idx = 0;
1353 } else if (SWT.END == e.keyCode) {
1354 idx = _data._expandedItems.length - 1;
1355 } else if (SWT.ARROW_DOWN == e.keyCode) {
1356 idx = getSelectedIndex();
1357 if (idx < 0) {
1358 idx = 0;
1359 } else if (idx < _data._expandedItems.length - 1) {
1360 idx++;
1361 }
1362 } else if (SWT.ARROW_UP == e.keyCode) {
1363 idx = getSelectedIndex();
1364 if (idx < 0) {
1365 idx = 0;
1366 } else if (idx > 0) {
1367 idx--;
1368 }
1369 } else if (SWT.ARROW_LEFT == e.keyCode) {
1370 selectPrevEvent();
1371 } else if (SWT.ARROW_RIGHT == e.keyCode) {
1372 selectNextEvent();
1373 } else if (SWT.PAGE_DOWN == e.keyCode) {
1374 int page = countPerPage();
1375 idx = getSelectedIndex();
1376 if (idx < 0) {
1377 idx = 0;
1378 }
1379 idx += page;
1380 if (idx >= _data._expandedItems.length) {
1381 idx = _data._expandedItems.length - 1;
1382 }
1383 } else if (SWT.PAGE_UP == e.keyCode) {
1384 int page = countPerPage();
1385 idx = getSelectedIndex();
1386 if (idx < 0) {
1387 idx = 0;
1388 }
1389 idx -= page;
1390 if (idx < 0) {
1391 idx = 0;
1392 }
1393 } else if (SWT.CR == e.keyCode) {
1394 idx = getSelectedIndex();
1395 if (idx >= 0) {
1396 if (_data._expandedItems[idx]._hasChildren) {
1397 toggle(idx);
1398 } else {
1399 fireDefaultSelection();
1400 }
1401 }
1402 idx = -1;
1403 }
1404 if (idx >= 0) {
1405 selectItem(idx, false);
1406 fireSelectionChanged();
1407 }
1408 }
1409
1410 @Override
1411 public void keyReleased(KeyEvent e) {
1412 }
1413
1414 @Override
1415 public void focusGained(FocusEvent e) {
1416 _isInFocus = true;
1417 if (mouseScrollFilterListener == null) {
1418 mouseScrollFilterListener = new Listener() {
1419 // This filter is used to prevent horizontal scrolling of the view
1420 // when the mouse wheel is used to zoom
1421 @Override
1422 public void handleEvent(Event event) {
1423 event.doit = false;
1424 }
1425 };
1426 getDisplay().addFilter(SWT.MouseWheel, mouseScrollFilterListener);
1427 }
1428 redraw();
1429 }
1430
1431 @Override
1432 public void focusLost(FocusEvent e) {
1433 _isInFocus = false;
1434 if (mouseScrollFilterListener != null) {
1435 getDisplay().removeFilter(SWT.MouseWheel, mouseScrollFilterListener);
1436 mouseScrollFilterListener = null;
1437 }
1438 if (DRAG_NONE != _dragState) {
1439 setCapture(false);
1440 _dragState = DRAG_NONE;
1441 }
1442 redraw();
1443 }
1444
1445 /**
1446 * @return If the current view is focused
1447 */
1448 public boolean isInFocus() {
1449 return _isInFocus;
1450 }
1451
1452 /**
1453 * Provide the possibility to control the wait cursor externally e.g. data
1454 * requests in progress
1455 *
1456 * @param waitInd Should we wait indefinitely?
1457 */
1458 public void waitCursor(boolean waitInd) {
1459 // Update cursor as indicated
1460 if (waitInd) {
1461 setCursor(_WaitCursor);
1462 _isWaitCursor = true;
1463 } else {
1464 setCursor(null);
1465 _isWaitCursor = false;
1466 }
1467
1468 // Get ready for next mouse move
1469 _isDragCursor3 = false;
1470 }
1471
1472 /**
1473 * <p>
1474 * If the x, y position is over the vertical split line (name to time
1475 * ranges), then change the cursor to a drag cursor to indicate the user the
1476 * possibility of resizing
1477 * </p>
1478 *
1479 * @param x
1480 * @param y
1481 */
1482 void updateCursor(int x, int y) {
1483 // if Wait cursor not active, check for the need to change to a drag
1484 // cursor
1485 if (_isWaitCursor == false) {
1486 boolean isSplitLine = isOverSplitLine(x);
1487 // No dragcursor is name space is fixed to zero
1488 if (isSplitLine && !_isDragCursor3 && _timeProvider.getNameSpace() > 0) {
1489 setCursor(_dragCursor3);
1490 _isDragCursor3 = true;
1491 } else if (!isSplitLine && _isDragCursor3) {
1492 setCursor(null);
1493 _isDragCursor3 = false;
1494 }
1495 }
1496 }
1497
1498 @Override
1499 public void mouseMove(MouseEvent e) {
1500 if (null == _timeProvider) {
1501 return;
1502 }
1503 Point size = getCtrlSize();
1504 if (DRAG_TRACE_ITEM == _dragState) {
1505 int nameWidth = _timeProvider.getNameSpace();
1506 int x = e.x - nameWidth;
1507 if (x > 0 && size.x > nameWidth && _dragX != x) {
1508 _dragX = x;
1509 double pixelsPerNanoSec = (size.x - nameWidth <= RIGHT_MARGIN) ? 0 : (double) (size.x - nameWidth - RIGHT_MARGIN) / (_time1bak - _time0bak);
1510 long timeDelta = (long) ((pixelsPerNanoSec == 0) ? 0 : ((_dragX - _dragX0) / pixelsPerNanoSec));
1511 long time1 = _time1bak - timeDelta;
1512 long maxTime = _timeProvider.getMaxTime();
1513 if (time1 > maxTime) {
1514 time1 = maxTime;
1515 }
1516 long time0 = time1 - (_time1bak - _time0bak);
1517 if (time0 < _timeProvider.getMinTime()) {
1518 time0 = _timeProvider.getMinTime();
1519 time1 = time0 + (_time1bak - _time0bak);
1520 }
1521 _timeProvider.setStartFinishTime(time0, time1);
1522 }
1523 } else if (DRAG_SPLIT_LINE == _dragState) {
1524 _dragX = e.x;
1525 _timeProvider.setNameSpace(e.x);
1526 } else if (DRAG_NONE == _dragState) {
1527 boolean mouseOverSplitLine = isOverSplitLine(e.x);
1528 if (_mouseOverSplitLine != mouseOverSplitLine) {
1529 redraw();
1530 }
1531 _mouseOverSplitLine = mouseOverSplitLine;
1532 }
1533 updateCursor(e.x, e.y);
1534 }
1535
1536 @Override
1537 public void mouseDoubleClick(MouseEvent e) {
1538 if (null == _timeProvider) {
1539 return;
1540 }
1541 if (1 == e.button) {
1542 if (isOverSplitLine(e.x) && _timeProvider.getNameSpace() != 0) {
1543 _timeProvider.setNameSpace(_idealNameSpace);
1544 boolean mouseOverSplitLine = isOverSplitLine(e.x);
1545 if (_mouseOverSplitLine != mouseOverSplitLine) {
1546 redraw();
1547 }
1548 _mouseOverSplitLine = mouseOverSplitLine;
1549 return;
1550 }
1551 int idx = getItemIndexAtY(e.y);
1552 if (idx >= 0) {
1553 selectItem(idx, false);
1554 fireDefaultSelection();
1555 }
1556 }
1557 }
1558
1559 @Override
1560 public void mouseDown(MouseEvent e) {
1561 if (null == _timeProvider) {
1562 return;
1563 }
1564 int idx;
1565 if (1 == e.button) {
1566 int nameSpace = _timeProvider.getNameSpace();
1567 if (nameSpace != 0) {
1568 if (isOverSplitLine(e.x)) {
1569 _dragState = DRAG_SPLIT_LINE;
1570 _dragX = _dragX0 = e.x;
1571 _time0bak = _timeProvider.getTime0();
1572 _time1bak = _timeProvider.getTime1();
1573 redraw();
1574 return;
1575 }
1576 }
1577
1578 idx = getItemIndexAtY(e.y);
1579 if (idx >= 0) {
1580 Item item = _data._expandedItems[idx];
1581 if (item._hasChildren && e.x < nameSpace && e.x < MARGIN + (item.level + 1) * EXPAND_SIZE) {
1582 toggle(idx);
1583 } else {
1584 long hitTime = getTimeAtX(e.x);
1585 if (hitTime >= 0) {
1586 // _timeProvider.setSelectedTimeInt(hitTime, false);
1587 setCapture(true);
1588 _dragState = DRAG_TRACE_ITEM;
1589 _dragX = _dragX0 = e.x - nameSpace;
1590 _time0bak = _timeProvider.getTime0();
1591 _time1bak = _timeProvider.getTime1();
1592 }
1593 }
1594 selectItem(idx, false);
1595 fireSelectionChanged();
1596 } else {
1597 selectItem(idx, false); // clear selection
1598 redraw();
1599 fireSelectionChanged();
1600 }
1601 }
1602 }
1603
1604 @Override
1605 public void mouseUp(MouseEvent e) {
1606 if (DRAG_NONE != _dragState) {
1607 setCapture(false);
1608 if (DRAG_TRACE_ITEM == _dragState) {
1609 // Notify time provider to check the need for listener
1610 // notification
1611 _timeProvider.notifyStartFinishTime();
1612 if (_dragX == _dragX0) { // click without drag
1613 long time = getTimeAtX(e.x);
1614 _timeProvider.setSelectedTimeNotify(time, false);
1615 }
1616 } else if (DRAG_SPLIT_LINE == _dragState) {
1617 redraw();
1618 }
1619 _dragState = DRAG_NONE;
1620 }
1621 }
1622
1623 @Override
1624 public void mouseEnter(MouseEvent e) {
1625 }
1626
1627 @Override
1628 public void mouseExit(MouseEvent e) {
1629 if (_mouseOverSplitLine) {
1630 _mouseOverSplitLine = false;
1631 redraw();
1632 }
1633 }
1634
1635 @Override
1636 public void mouseHover(MouseEvent e) {
1637 }
1638
1639 @Override
1640 public void mouseScrolled(MouseEvent e) {
1641 if ((mouseScrollFilterListener == null) || _dragState != DRAG_NONE) {
1642 return;
1643 }
1644 boolean zoomScroll = false;
1645 Point p = getParent().toControl(getDisplay().getCursorLocation());
1646 Point parentSize = getParent().getSize();
1647 if (p.x >= 0 && p.x < parentSize.x && p.y >= 0 && p.y < parentSize.y) {
1648 // over the parent control
1649 if (e.x > getCtrlSize().x) {
1650 // over the horizontal scroll bar
1651 zoomScroll = false;
1652 } else if (e.y >= 0 && e.y < getCtrlSize().y && e.x < _timeProvider.getNameSpace()) {
1653 // over the name space
1654 zoomScroll = false;
1655 } else {
1656 zoomScroll = true;
1657 }
1658 }
1659 if (zoomScroll && _timeProvider.getTime0() != _timeProvider.getTime1()) {
1660 if (e.count > 0) {
1661 zoom(true);
1662 } else if (e.count < 0) {
1663 zoom(false);
1664 }
1665 } else {
1666 setTopIndex(getTopIndex() - e.count);
1667 }
1668 }
1669
1670 @Override
1671 public void controlMoved(ControlEvent e) {
1672 }
1673
1674 @Override
1675 public void controlResized(ControlEvent e) {
1676 adjustScrolls();
1677 }
1678
1679 @Override
1680 public void widgetDefaultSelected(SelectionEvent e) {
1681 }
1682
1683 @Override
1684 public void widgetSelected(SelectionEvent e) {
1685 if (e.widget == getVerticalBar()) {
1686 setTopIndex(getVerticalBar().getSelection());
1687 } else if (e.widget == getHorizontalBar() && null != _timeProvider) {
1688 int start = getHorizontalBar().getSelection();
1689 long time0 = _timeProvider.getTime0();
1690 long time1 = _timeProvider.getTime1();
1691 long timeMin = _timeProvider.getMinTime();
1692 long timeMax = _timeProvider.getMaxTime();
1693 long delta = timeMax - timeMin;
1694
1695 long range = time1 - time0;
1696 // _timeRangeFixed = true;
1697 time0 = timeMin + Math.round(delta * ((double) start / H_SCROLLBAR_MAX));
1698 time1 = time0 + range;
1699
1700 // TODO: Follow-up with Bug 310310
1701 // In Linux SWT.DRAG is the only value received
1702 // https://bugs.eclipse.org/bugs/show_bug.cgi?id=310310
1703 if (e.detail == SWT.DRAG) {
1704 _timeProvider.setStartFinishTime(time0, time1);
1705 } else {
1706 _timeProvider.setStartFinishTimeNotify(time0, time1);
1707 }
1708 }
1709 }
1710
1711 /**
1712 * @return The current visibility of the vertical scroll bar
1713 */
1714 public boolean isVisibleVerticalScroll() {
1715 return _visibleVerticalScroll;
1716 }
1717
1718 @Override
1719 public int getBorderWidth() {
1720 return _borderWidth;
1721 }
1722
1723 /**
1724 * Set the border width
1725 *
1726 * @param borderWidth
1727 * The width
1728 */
1729 public void setBorderWidth(int borderWidth) {
1730 this._borderWidth = borderWidth;
1731 }
1732
1733 /**
1734 * @return The current height of the header row
1735 */
1736 public int getHeaderHeight() {
1737 return _headerHeight;
1738 }
1739
1740 /**
1741 * Set the height of the header row
1742 *
1743 * @param headerHeight
1744 * The height
1745 */
1746 public void setHeaderHeight(int headerHeight) {
1747 this._headerHeight = headerHeight;
1748 }
1749
1750 /**
1751 * @return The height of regular item rows
1752 */
1753 public int getItemHeight() {
1754 return _itemHeight;
1755 }
1756
1757 /**
1758 * Set the height of regular itew rows
1759 *
1760 * @param rowHeight
1761 * The height
1762 */
1763 public void setItemHeight(int rowHeight) {
1764 this._itemHeight = rowHeight;
1765 }
1766
1767 /**
1768 * Set the minimum item width
1769 *
1770 * @param width The minimum width
1771 */
1772 public void setMinimumItemWidth(int width) {
1773 this._minimumItemWidth = width;
1774 }
1775
1776 /**
1777 * @return The minimum item width
1778 */
1779 public int getMinimumItemWidth() {
1780 return _minimumItemWidth;
1781 }
1782
1783 /**
1784 * @return The entries that are currently filtered out
1785 */
1786 public Vector<ITimeGraphEntry> getFilteredOut() {
1787 return _data.getFilteredOut();
1788 }
1789
1790 // @Override
1791 @Override
1792 public void addSelectionChangedListener(ISelectionChangedListener listener) {
1793 if (listener != null) {
1794 if (!_selectionChangedListeners.contains(listener)) {
1795 _selectionChangedListeners.add(listener);
1796 }
1797 }
1798 }
1799
1800 // @Override
1801 @Override
1802 public void removeSelectionChangedListener(ISelectionChangedListener listener) {
1803 if (listener != null) {
1804 _selectionChangedListeners.remove(listener);
1805 }
1806 }
1807
1808 // @Override
1809 @Override
1810 public void setSelection(ISelection selection) {
1811 if (selection instanceof TimeGraphSelection) {
1812 TimeGraphSelection sel = (TimeGraphSelection) selection;
1813 Object ob = sel.getFirstElement();
1814 if (ob instanceof ITimeGraphEntry) {
1815 ITimeGraphEntry trace = (ITimeGraphEntry) ob;
1816 selectItem(trace, false);
1817 }
1818 }
1819
1820 }
1821
1822 private class ItemData {
1823 public Item[] _expandedItems = new Item[0];
1824 public Item[] _items = new Item[0];
1825 private ITimeGraphEntry _traces[] = new ITimeGraphEntry[0];
1826 private boolean traceFilter[] = new boolean[0];
1827 private final Vector<ITimeGraphEntry> filteredOut = new Vector<ITimeGraphEntry>();
1828 public ITimeGraphPresentationProvider provider;
1829
1830 public ItemData() {
1831 }
1832
1833 Item findItem(ITimeGraphEntry entry) {
1834 if (entry == null) {
1835 return null;
1836 }
1837
1838 for (int i = 0; i < _items.length; i++) {
1839 Item item = _items[i];
1840 if (item._trace == entry) {
1841 return item;
1842 }
1843 }
1844
1845 return null;
1846 }
1847
1848 int findItemIndex(ITimeGraphEntry trace) {
1849 if (trace == null) {
1850 return -1;
1851 }
1852
1853 for (int i = 0; i < _expandedItems.length; i++) {
1854 Item item = _expandedItems[i];
1855 if (item._trace == trace) {
1856 return i;
1857 }
1858 }
1859
1860 return -1;
1861 }
1862
1863 public void refreshData() {
1864 List<Item> itemList = new ArrayList<Item>();
1865 filteredOut.clear();
1866 for (int i = 0; i < _traces.length; i++) {
1867 ITimeGraphEntry entry = _traces[i];
1868 refreshData(itemList, null, 0, entry);
1869 }
1870 _items = itemList.toArray(new Item[0]);
1871 updateExpandedItems();
1872 }
1873
1874 private void refreshData(List<Item> itemList, Item parent, int level, ITimeGraphEntry entry) {
1875 Item item = new Item(entry, entry.getName(), level);
1876 if (parent != null) {
1877 parent.children.add(item);
1878 }
1879 item.itemHeight = provider.getItemHeight(entry);
1880 itemList.add(item);
1881 if (entry.hasChildren()) {
1882 item._expanded = true;
1883 item._hasChildren = true;
1884 for (ITimeGraphEntry child : entry.getChildren()) {
1885 refreshData(itemList, item, level + 1, child);
1886 }
1887 }
1888 }
1889
1890 public void updateExpandedItems() {
1891 List<Item> expandedItemList = new ArrayList<Item>();
1892 for (int i = 0; i < _traces.length; i++) {
1893 ITimeGraphEntry entry = _traces[i];
1894 Item item = findItem(entry);
1895 refreshExpanded(expandedItemList, item);
1896 }
1897 _expandedItems = expandedItemList.toArray(new Item[0]);
1898 }
1899
1900 private void refreshExpanded(List<Item> expandedItemList, Item item) {
1901 expandedItemList.add(item);
1902 if (item._hasChildren && item._expanded) {
1903 for (Item child : item.children) {
1904 refreshExpanded(expandedItemList, child);
1905 }
1906 }
1907 }
1908
1909 public void expandItem(int idx) {
1910 if (idx < 0 || idx >= _expandedItems.length) {
1911 return;
1912 }
1913 Item item = _expandedItems[idx];
1914 if (item._hasChildren && !item._expanded) {
1915 item._expanded = true;
1916 updateExpandedItems();
1917 }
1918 }
1919
1920 public void refreshData(ITimeGraphEntry traces[]) {
1921 if (traces == null || traces.length == 0) {
1922 traceFilter = null;
1923 } else if (traceFilter == null || traces.length != traceFilter.length) {
1924 traceFilter = new boolean[traces.length];
1925 java.util.Arrays.fill(traceFilter, true);
1926 }
1927
1928 _traces = traces;
1929 refreshData();
1930 }
1931
1932 public ITimeGraphEntry[] getTraces() {
1933 return _traces;
1934 }
1935
1936 public boolean[] getTraceFilter() {
1937 return traceFilter;
1938 }
1939
1940 public Vector<ITimeGraphEntry> getFilteredOut() {
1941 return filteredOut;
1942 }
1943 }
1944
1945 private class Item {
1946 public boolean _expanded;
1947 public boolean _selected;
1948 public boolean _hasChildren;
1949 public int itemHeight;
1950 public int level;
1951 public List<Item> children;
1952 public String _name;
1953 public ITimeGraphEntry _trace;
1954
1955 public Item(ITimeGraphEntry trace, String name, int level) {
1956 this._trace = trace;
1957 this._name = name;
1958 this.level = level;
1959 this.children = new ArrayList<Item>();
1960 }
1961
1962 @Override
1963 public String toString() {
1964 return _name;
1965 }
1966 }
1967
1968 }
1969
Tracecompass - Deliverables
This page took 0.141432 seconds and 5 git commands to generate.