projects / deliverable / tracecompass.git / blame
? search:
summary | shortlog | log | commit | commitdiff | tree
blob | blame (incremental) | history | HEAD
April 27/2010
[deliverable/tracecompass.git] / org.eclipse.linuxtools.tmf.ui / src / org / eclipse / linuxtools / tmf / ui / viewers / timeAnalysis / widgets / TmfTimeStatesCtrl.java
CommitLineData
b0d3496e
ASL		 1/*****************************************************************************\r
2 * Copyright (c) 2007, 2008 Intel Corporation.\r
3 * All rights reserved. This program and the accompanying materials\r
4 * are made available under the terms of the Eclipse Public License v1.0\r
5 * which accompanies this distribution, and is available at\r
6 * http://www.eclipse.org/legal/epl-v10.html\r
7 *\r
8 * Contributors:\r
9 * Intel Corporation - Initial API and implementation\r
10 * Ruslan A. Scherbakov, Intel - Initial API and implementation\r
11 * Alvaro Sanchex-Leon - Udpated for TMF\r
12 *\r
13 * $Id: ThreadStatesCtrl.java,v 1.15 2008/07/11 13:49:01 aalexeev Exp $ \r
14 *****************************************************************************/\r
15\r
16package org.eclipse.linuxtools.tmf.ui.viewers.timeAnalysis.widgets;\r
17\r
18import java.util.ArrayList;\r
19import java.util.HashMap;\r
20import java.util.Iterator;\r
21import java.util.List;\r
22import java.util.Map;\r
23import java.util.Vector;\r
24\r
25import org.eclipse.jface.viewers.ISelection;\r
26import org.eclipse.jface.viewers.ISelectionChangedListener;\r
27import org.eclipse.jface.viewers.ISelectionProvider;\r
28import org.eclipse.linuxtools.tmf.ui.viewers.timeAnalysis.Messages;\r
29import org.eclipse.linuxtools.tmf.ui.viewers.timeAnalysis.TmfTimeAnalysisProvider;\r
30import org.eclipse.linuxtools.tmf.ui.viewers.timeAnalysis.model.ITimeEvent;\r
31import org.eclipse.linuxtools.tmf.ui.viewers.timeAnalysis.model.ITmfTimeAnalysisEntry;\r
32import org.eclipse.linuxtools.tmf.ui.viewers.timeAnalysis.model.TimeEvent;\r
33import org.eclipse.osgi.util.NLS;\r
34import org.eclipse.swt.SWT;\r
35import org.eclipse.swt.events.ControlEvent;\r
36import org.eclipse.swt.events.ControlListener;\r
37import org.eclipse.swt.events.FocusEvent;\r
38import org.eclipse.swt.events.FocusListener;\r
39import org.eclipse.swt.events.KeyEvent;\r
40import org.eclipse.swt.events.KeyListener;\r
41import org.eclipse.swt.events.MouseEvent;\r
42import org.eclipse.swt.events.MouseListener;\r
43import org.eclipse.swt.events.MouseMoveListener;\r
44import org.eclipse.swt.events.MouseTrackListener;\r
45import org.eclipse.swt.events.MouseWheelListener;\r
46import org.eclipse.swt.events.PaintEvent;\r
47import org.eclipse.swt.events.SelectionEvent;\r
48import org.eclipse.swt.events.SelectionListener;\r
49import org.eclipse.swt.events.TraverseEvent;\r
50import org.eclipse.swt.events.TraverseListener;\r
51import org.eclipse.swt.graphics.Cursor;\r
52import org.eclipse.swt.graphics.GC;\r
53import org.eclipse.swt.graphics.Image;\r
54import org.eclipse.swt.graphics.Point;\r
55import org.eclipse.swt.graphics.Rectangle;\r
56import org.eclipse.swt.widgets.Composite;\r
a5823d5f
ASL		 57import org.eclipse.swt.widgets.Event;\r
58import org.eclipse.swt.widgets.Listener;\r
b0d3496e
ASL		 59import org.eclipse.swt.widgets.ScrollBar;\r
60\r
41dc35d0
FC		 61/**\r
62 * @author alvaro\r
63 * \r
64 */\r
b0d3496e
ASL		 65public class TmfTimeStatesCtrl extends TraceCtrl implements FocusListener,\r
66 KeyListener, MouseMoveListener, MouseListener, MouseWheelListener,\r
67 ControlListener, SelectionListener, MouseTrackListener,\r
68 TraverseListener, ISelectionProvider {\r
69\r
70 public static final boolean DEFAULT_DRAW_THREAD_JOIN = true;\r
71 public static final boolean DEFAULT_DRAW_THREAD_WAIT = true;\r
72 public static final boolean DEFAULT_DRAW_THREAD_RELEASE = true;\r
a5823d5f 73 public static int H_SCROLLBAR_MAX = Integer.MAX_VALUE - 1;\r
b0d3496e
ASL		 74\r
75 private final double zoomCoeff = 1.5;\r
76\r
77 private ITimeDataProvider _timeProvider;\r
78 private boolean _isInFocus = false;\r
79 private boolean _isDragCursor3 = false;\r
41dc35d0 80 private boolean _isWaitCursor = true;\r
b0d3496e 81 private boolean _mouseHover = false;\r
a5823d5f 82 private int _itemHeightDefault = 19;\r
b0d3496e
ASL		 83 private int _itemHeight = _itemHeightDefault;\r
84 private int _topItem = 0;\r
85 private int _dragState = 0;\r
86 private int _hitIdx = 0;\r
87 private int _dragX0 = 0;\r
88 private int _dragX = 0;\r
89 private int _idealNameWidth = 0;\r
90 // private double _timeStep = 10000000;\r
91 private long _time0bak;\r
92 private long _time1bak;\r
93 private TmfTimeAnalysisProvider utilImpl = null;\r
94 private ItemData _data = null;\r
95 private List<SelectionListener> _selectionListeners;\r
96 private List<ISelectionChangedListener> _selectionChangedListeners = new ArrayList<ISelectionChangedListener>();\r
97 private Rectangle _rect0 = new Rectangle(0, 0, 0, 0);\r
98 private Rectangle _rect1 = new Rectangle(0, 0, 0, 0);\r
99 private Cursor _dragCursor3;\r
41dc35d0 100 private Cursor _WaitCursor;\r
b0d3496e
ASL		 101 private boolean drawTracesInteraction = false;\r
102 private boolean drawTraceJoins = DEFAULT_DRAW_THREAD_JOIN;\r
103 private boolean drawTraceWaits = DEFAULT_DRAW_THREAD_WAIT;\r
104 private boolean drawTraceReleases = DEFAULT_DRAW_THREAD_RELEASE;\r
105\r
106 // Vertical formatting formatting for the state control view\r
107 private boolean _visibleVerticalScroll = true;\r
108 private int _borderWidth = 0;\r
109 private int _headerHeight = 0;\r
110\r
a5823d5f
ASL		 111 private Listener mouseScrollFilterListener;\r
112\r
b0d3496e
ASL		 113 public TmfTimeStatesCtrl(Composite parent, TraceColorScheme colors,\r
114 TmfTimeAnalysisProvider rutilImp) {\r
115\r
116 super(parent, colors, SWT.NO_BACKGROUND | SWT.V_SCROLL | SWT.H_SCROLL\r
117 | SWT.DOUBLE_BUFFERED);\r
118\r
119 this.utilImpl = rutilImp;\r
120 _data = new ItemData(utilImpl);\r
121\r
122 addFocusListener(this);\r
123 addMouseListener(this);\r
124 addMouseMoveListener(this);\r
125 addMouseTrackListener(this);\r
126 addMouseWheelListener(this);\r
127 addTraverseListener(this);\r
128 addKeyListener(this);\r
129 addControlListener(this);\r
130 ScrollBar scrollVer = getVerticalBar();\r
131 ScrollBar scrollHor = getHorizontalBar();\r
132 if (scrollVer != null) {\r
133 scrollVer.addSelectionListener(this);\r
134 scrollVer.setVisible(_visibleVerticalScroll);\r
135 }\r
136\r
137 if (scrollHor != null) {\r
138 scrollHor.addSelectionListener(this);\r
139 }\r
a5823d5f
ASL		 140 mouseScrollFilterListener = new Listener() {\r
141 // This filter is used to prevent scrolling of the view when the\r
142 // mouse wheel is used to zoom\r
143 public void handleEvent(Event event) {\r
144 event.doit = false;\r
145 }\r
146 };\r
b0d3496e
ASL		 147\r
148 _dragCursor3 = new Cursor(super.getDisplay(), SWT.CURSOR_SIZEWE);\r
41dc35d0 149 _WaitCursor = new Cursor(super.getDisplay(), SWT.CURSOR_WAIT);\r
b0d3496e
ASL		 150 }\r
151\r
4e3aa37d 152 @Override\r
b0d3496e
ASL		 153 public void dispose() {\r
154 super.dispose();\r
155 _dragCursor3.dispose();\r
41dc35d0 156 _WaitCursor.dispose();\r
b0d3496e
ASL		 157 }\r
158\r
159 public void setTimeProvider(ITimeDataProvider timeProvider) {\r
160 _timeProvider = timeProvider;\r
161 adjustScrolls();\r
162 redraw();\r
163 }\r
164\r
165 public void addSelectionListener(SelectionListener listener) {\r
166 if (listener == null)\r
167 SWT.error(SWT.ERROR_NULL_ARGUMENT);\r
168 if (null == _selectionListeners)\r
169 _selectionListeners = new ArrayList<SelectionListener>();\r
170 _selectionListeners.add(listener);\r
171 }\r
172\r
173 public void removeSelectionListener(SelectionListener listener) {\r
174 if (null != _selectionListeners)\r
175 _selectionListeners.remove(listener);\r
176 }\r
177\r
178 public void fireSelectionChanged() {\r
179 if (null != _selectionListeners) {\r
180 Iterator<SelectionListener> it = _selectionListeners.iterator();\r
181 while (it.hasNext()) {\r
182 SelectionListener listener = it.next();\r
183 listener.widgetSelected(null);\r
184 }\r
185 }\r
186 }\r
187\r
188 public void fireDefaultSelection() {\r
189 if (null != _selectionListeners) {\r
190 Iterator<SelectionListener> it = _selectionListeners.iterator();\r
191 while (it.hasNext()) {\r
192 SelectionListener listener = it.next();\r
193 listener.widgetDefaultSelected(null);\r
194 }\r
195 }\r
196 }\r
197\r
198 public Object[] getTraces() {\r
199 return _data.getTraces();\r
200 }\r
201\r
202 public boolean[] getTraceFilter() {\r
203 return _data.getTraceFilter();\r
204 }\r
205\r
206 public void refreshData() {\r
207 _data.refreshData();\r
208 adjustScrolls();\r
209 redraw();\r
210 }\r
211\r
212 public void refreshData(Object traces[]) {\r
213 _data.refreshData(traces);\r
214 adjustScrolls();\r
215 redraw();\r
216 }\r
217\r
218 public void refreshPartial(ITmfTimeAnalysisEntry parent, TimeEvent item) {\r
219 _data.refreshPartial(parent, item);\r
220 adjustScrolls();\r
221 redraw();\r
222 }\r
223\r
224 public void adjustScrolls() {\r
225 if (null == _timeProvider) {\r
226 getVerticalBar().setValues(0, 1, 1, 1, 1, 1);\r
227 getHorizontalBar().setValues(0, 1, 1, 1, 1, 1);\r
228 return;\r
229 }\r
71c964eb
ASL		 230\r
231 // Vertical scroll bar\r
b0d3496e
ASL		 232 int page = countPerPage();\r
233 if (_topItem + page > _data._items.length)\r
234 _topItem = _data._items.length - page;\r
235 if (_topItem < 0)\r
236 _topItem = 0;\r
237 getVerticalBar().setValues(_topItem, 0, _data._items.length, page, 1,\r
238 page);\r
71c964eb
ASL		 239\r
240 // HORIZONTAL BAR\r
241 // Visible window\r
b0d3496e
ASL		 242 long time0 = _timeProvider.getTime0();\r
243 long time1 = _timeProvider.getTime1();\r
71c964eb 244 // Time boundaries\r
b0d3496e
ASL		 245 long timeMin = _timeProvider.getMinTime();\r
246 long timeMax = _timeProvider.getMaxTime();\r
247\r
248 long delta = timeMax - timeMin;\r
249\r
250 int timePos = 0;\r
a5823d5f 251 int thumb = H_SCROLLBAR_MAX;\r
71c964eb 252\r
b0d3496e 253 if (delta != 0) {\r
71c964eb 254 // Thumb size (page size)\r
a5823d5f 255 thumb = Math.max(1, (int) (H_SCROLLBAR_MAX * ((double) (time1 - time0) / delta)));\r
71c964eb
ASL		 256 // At the beginning of visible window\r
257 timePos = (int) (H_SCROLLBAR_MAX * ((double) (time0 - timeMin) / delta));\r
b0d3496e
ASL		 258 }\r
259\r
71c964eb
ASL		 260 // position, minimum, maximum, thumb size, increment (half page)t, page\r
261 // increment size (full page)\r
262 getHorizontalBar().setValues(timePos, 0, H_SCROLLBAR_MAX, thumb,\r
263 Math.max(1, thumb / 2), Math.max(2, thumb));\r
b0d3496e
ASL		 264 }\r
265\r
266 boolean ensureVisibleItem(int idx, boolean redraw) {\r
267 boolean changed = false;\r
268 if (idx < 0) {\r
269 for (idx = 0; idx < _data._items.length; idx++) {\r
270 if (((Item) _data._items[idx])._selected)\r
271 break;\r
272 }\r
273 }\r
274 if (idx >= _data._items.length)\r
275 return changed;\r
276 if (idx < _topItem) {\r
277 _topItem = idx;\r
278 getVerticalBar().setSelection(_topItem);\r
279 if (redraw)\r
280 redraw();\r
281 changed = true;\r
282 } else {\r
283 int page = countPerPage();\r
284 if (idx >= _topItem + page) {\r
285 _topItem = idx - page + 1;\r
286 getVerticalBar().setSelection(_topItem);\r
287 if (redraw)\r
288 redraw();\r
289 changed = true;\r
290 }\r
291 }\r
292 return changed;\r
293 }\r
294\r
295 public ISelection getSelection() {\r
296 PlainSelection sel = new PlainSelection();\r
297 ITmfTimeAnalysisEntry trace = getSelectedTrace();\r
298 if (null != trace && null != _timeProvider) {\r
299 long selectedTime = _timeProvider.getSelectedTime();\r
300 ITimeEvent event = Utils.findEvent(trace, selectedTime, 0);\r
301 if (event != null)\r
302 sel.add(event);\r
303 else\r
304 sel.add(trace);\r
305 }\r
306 return sel;\r
307 }\r
308\r
309 public ISelection getSelectionTrace() {\r
310 PlainSelection sel = new PlainSelection();\r
311 ITmfTimeAnalysisEntry trace = getSelectedTrace();\r
312 if (null != trace) {\r
313 sel.add(trace);\r
314 }\r
315 return sel;\r
316 }\r
317\r
318 public void selectTrace(int n) {\r
319 if (n != 1 && n != -1)\r
320 return;\r
321 boolean changed = false;\r
322 int lastSelection = -1;\r
323 for (int i = 0; i < _data._items.length; i++) {\r
324 Item item = (Item) _data._items[i];\r
325 if (item._selected) {\r
326 lastSelection = i;\r
327 if (1 == n && i < _data._items.length - 1) {\r
328 item._selected = false;\r
329 if (item._hasChildren)\r
330 _data.expandItem(i, true);\r
331 item = (Item) _data._items[i + 1];\r
332 if (item._hasChildren) {\r
333 _data.expandItem(i + 1, true);\r
334 item = (Item) _data._items[i + 2];\r
335 }\r
336 item._selected = true;\r
337 changed = true;\r
338 } else if (-1 == n && i > 0) {\r
339 i--;\r
340 Item prevItem = (Item) _data._items[i];\r
341 if (prevItem._hasChildren) {\r
342 if (prevItem._expanded) {\r
343 if (i > 0) {\r
344 i--;\r
345 prevItem = (Item) _data._items[i];\r
346 }\r
347 }\r
348 if (!prevItem._expanded) {\r
349 int added = _data.expandItem(i, true);\r
350 prevItem = (Item) _data._items[i + added];\r
351 item._selected = false;\r
352 prevItem._selected = true;\r
353 changed = true;\r
354 }\r
355 } else {\r
356 item._selected = false;\r
357 prevItem._selected = true;\r
358 changed = true;\r
359 }\r
360 }\r
361 break;\r
362 }\r
363 }\r
364 if (lastSelection < 0 && _data._items.length > 0) {\r
365 Item item = (Item) _data._items[0];\r
366 if (item._hasChildren) {\r
367 _data.expandItem(0, true);\r
368 item = (Item) _data._items[1];\r
369 item._selected = true;\r
370 changed = true;\r
371 } else {\r
372 item._selected = true;\r
373 changed = true;\r
374 }\r
375 }\r
376 if (changed) {\r
377 ensureVisibleItem(-1, false);\r
378 redraw();\r
379 fireSelectionChanged();\r
380 }\r
381 }\r
382\r
383 public void selectEvent(int n) {\r
384 if (null == _timeProvider)\r
385 return;\r
386 ITmfTimeAnalysisEntry trace = getSelectedTrace();\r
a5823d5f 387 if (trace == _timeProvider || trace == null)\r
b0d3496e
ASL		 388 return;\r
389 long selectedTime = _timeProvider.getSelectedTime();\r
390 long endTime = _timeProvider.getEndTime();\r
391 ITimeEvent nextEvent;\r
a5823d5f 392 if (-1 == n && selectedTime > endTime)\r
b0d3496e
ASL		 393 nextEvent = Utils.findEvent(trace, selectedTime, 0);\r
394 else\r
395 nextEvent = Utils.findEvent(trace, selectedTime, n);\r
396 if (null == nextEvent && -1 == n)\r
397 nextEvent = Utils.getFirstEvent(trace);\r
398 if (null != nextEvent) {\r
399 _timeProvider.setSelectedTimeInt(nextEvent.getTime(), true);\r
400 fireSelectionChanged();\r
401 } else if (1 == n) {\r
402 _timeProvider.setSelectedTimeInt(endTime, true);\r
403 fireSelectionChanged();\r
404 }\r
405 }\r
406\r
407 public void selectNextEvent() {\r
408 selectEvent(1);\r
409 }\r
410\r
411 public void selectPrevEvent() {\r
412 selectEvent(-1);\r
413 }\r
414\r
415 public void selectNextTrace() {\r
416 selectTrace(1);\r
417 }\r
418\r
419 public void selectPrevTrace() {\r
420 selectTrace(-1);\r
421 }\r
422\r
a5823d5f
ASL		 423 /**\r
424 * Zooming based on mouse cursor location with mouse scrolling\r
425 * \r
426 * @param zoomIn\r
427 */\r
428 public void zoom(boolean zoomIn) {\r
429 int globalX = getDisplay().getCursorLocation().x;\r
430 Point p = toControl(globalX, 0);\r
431 int nameSpace = _timeProvider.getNameSpace();\r
432 int timeSpace = _timeProvider.getTimeSpace();\r
433 int xPos = Math.max(nameSpace, Math.min(nameSpace + timeSpace, p.x));\r
434 long time0 = _timeProvider.getTime0();\r
435 long time1 = _timeProvider.getTime1();\r
436 long interval = time1 - time0;\r
437 if (interval == 0) {\r
438 interval = 1;\r
439 } // to allow getting out of single point interval\r
440 long newInterval;\r
441 if (zoomIn) {\r
442 newInterval = Math.max(Math.round((double) interval * 0.8), _timeProvider.getMinTimeInterval());\r
443 } else {\r
444 newInterval = Math.round((double) interval * 1.25);\r
445 }\r
446 long center = time0 + Math.round(((double) (xPos - nameSpace) / timeSpace * interval));\r
447 long newTime0 = center - Math.round((double) newInterval * (center - time0) / interval);\r
448 long newTime1 = newTime0 + newInterval;\r
449 _timeProvider.setStartFinishTime(newTime0, newTime1);\r
450 }\r
451\r
452 /**\r
453 * zoom in using single click\r
454 */\r
b0d3496e
ASL		 455 public void zoomIn() {\r
456 long _time0 = _timeProvider.getTime0();\r
457 long _time1 = _timeProvider.getTime1();\r
458 long _range = _time1 - _time0;\r
459 long selTime = _timeProvider.getSelectedTime();\r
460 if (selTime <= _time0 || selTime >= _time1) {\r
461 selTime = (_time0 + _time1) / 2;\r
462 }\r
463 long time0 = selTime - (long) ((selTime - _time0) / zoomCoeff);\r
464 long time1 = selTime + (long) ((_time1 - selTime) / zoomCoeff);\r
465\r
466 long inaccuracy = (_timeProvider.getMaxTime() - _timeProvider\r
467 .getMinTime())\r
468 - (time1 - time0);\r
469\r
470 // Trace.debug("selTime:" + selTime + " time0:" + time0 + " time1:"\r
471 // + time1 + " inaccuracy:" + inaccuracy);\r
472\r
473 if (inaccuracy > 0 && inaccuracy < 100) {\r
71c964eb 474 _timeProvider.setStartFinishTimeNotify(_timeProvider.getMinTime(),\r
b0d3496e
ASL		 475 _timeProvider.getMaxTime());\r
476 return;\r
477 }\r
478\r
479 long m = _timeProvider.getMinTimeInterval();\r
480 if ((time1 - time0) < m) {\r
481 time0 = selTime - (long) ((selTime - _time0) * m / _range);\r
482 time1 = time0 + m;\r
483 }\r
484\r
71c964eb 485 _timeProvider.setStartFinishTimeNotify(time0, time1);\r
b0d3496e
ASL		 486 }\r
487\r
a5823d5f
ASL		 488 /**\r
489 * zoom out using single click\r
490 */\r
b0d3496e
ASL		 491 public void zoomOut() {\r
492 long _time0 = _timeProvider.getTime0();\r
493 long _time1 = _timeProvider.getTime1();\r
494 long selTime = _timeProvider.getSelectedTime();\r
495 if (selTime <= _time0 || selTime >= _time1) {\r
496 selTime = (_time0 + _time1) / 2;\r
497 }\r
498 long time0 = (long) (selTime - (selTime - _time0) * zoomCoeff);\r
499 long time1 = (long) (selTime + (_time1 - selTime) * zoomCoeff);\r
500\r
501 long inaccuracy = (_timeProvider.getMaxTime() - _timeProvider\r
502 .getMinTime())\r
503 - (time1 - time0);\r
504 if (inaccuracy > 0 && inaccuracy < 100) {\r
71c964eb 505 _timeProvider.setStartFinishTimeNotify(_timeProvider.getMinTime(),\r
b0d3496e
ASL		 506 _timeProvider.getMaxTime());\r
507 return;\r
508 }\r
509\r
71c964eb 510 _timeProvider.setStartFinishTimeNotify(time0, time1);\r
b0d3496e
ASL		 511 }\r
512\r
513 public void groupTraces(boolean on) {\r
514 _data.groupTraces(on);\r
515 adjustScrolls();\r
516 redraw();\r
517 }\r
518\r
519 public void toggleTraceInteractionDrawing() {\r
520 drawTracesInteraction = !drawTracesInteraction;\r
521 redraw();\r
522 }\r
523\r
524 public void setTraceJoinDrawing(boolean on) {\r
525 drawTraceJoins = on;\r
526 drawTracesInteraction = true;\r
527 redraw();\r
528 }\r
529\r
530 public void setTraceWaitDrawing(boolean on) {\r
531 drawTraceWaits = on;\r
532 drawTracesInteraction = true;\r
533 redraw();\r
534 }\r
535\r
536 public void setTraceReleaseDrawing(boolean on) {\r
537 drawTraceReleases = on;\r
538 drawTracesInteraction = true;\r
539 redraw();\r
540 }\r
541\r
542 public boolean getTracesInteractionDrawing() {\r
543 return drawTracesInteraction;\r
544 }\r
545\r
546 public boolean getTraceJoinDrawing() {\r
547 return drawTraceJoins;\r
548 }\r
549\r
550 public boolean getTraceWaitDrawing() {\r
551 return drawTraceWaits;\r
552 }\r
553\r
554 public boolean getTraceReleaseDrawing() {\r
555 return drawTraceReleases;\r
556 }\r
557\r
558 public ITmfTimeAnalysisEntry getSelectedTrace() {\r
559 ITmfTimeAnalysisEntry trace = null;\r
560 int idx = getSelectedIndex();\r
561 if (idx >= 0 && _data._items[idx] instanceof TraceItem)\r
562 trace = ((TraceItem) _data._items[idx])._trace;\r
563 return trace;\r
564 }\r
565\r
566 public int getSelectedIndex() {\r
567 int idx = -1;\r
568 for (int i = 0; i < _data._items.length; i++) {\r
569 Item item = (Item) _data._items[i];\r
570 if (item._selected) {\r
571 idx = i;\r
572 break;\r
573 }\r
574 }\r
575 return idx;\r
576 }\r
577\r
578 boolean toggle(int idx) {\r
579 boolean toggled = false;\r
580 if (idx >= 0 && idx < _data._items.length) {\r
581 Item item = (Item) _data._items[idx];\r
582 if (item._hasChildren) {\r
583 item._expanded = !item._expanded;\r
584 _data.updateItems();\r
585 adjustScrolls();\r
586 redraw();\r
587 toggled = true;\r
588 }\r
589 }\r
590 return toggled;\r
591 }\r
592\r
593 int hitTest(int x, int y) {\r
594 if (x < 0 || y < 0)\r
595 return -1;\r
596 int hit = -1;\r
597 int idx = y / _itemHeight;\r
598 idx += _topItem;\r
599 if (idx < _data._items.length)\r
600 hit = idx;\r
601 return hit;\r
602 }\r
603\r
604 int hitSplitTest(int x, int y) {\r
605 if (x < 0 || y < 0 || null == _timeProvider)\r
606 return -1;\r
607 int w = 4;\r
608 int hit = -1;\r
609 int nameWidth = _timeProvider.getNameSpace();\r
610 if (x > nameWidth - w && x < nameWidth + w)\r
611 hit = 1;\r
612 return hit;\r
613 }\r
614\r
615 public Item getItem(Point pt) {\r
616 int idx = hitTest(pt.x, pt.y);\r
617 return idx >= 0 ? (Item) _data._items[idx] : null;\r
618 }\r
619\r
620 long hitTimeTest(int x, int y) {\r
621 if (null == _timeProvider)\r
622 return -1;\r
623 long hitTime = -1;\r
624 Point size = getCtrlSize();\r
625 long time0 = _timeProvider.getTime0();\r
626 long time1 = _timeProvider.getTime1();\r
627 int nameWidth = _timeProvider.getNameSpace();\r
628 x -= nameWidth;\r
629 if (x >= 0 && size.x >= nameWidth) {\r
a5823d5f 630 hitTime = time0 + (long) ((time1 - time0) * ((double) (x + 1) / (size.x - nameWidth - 1))) - 1;\r
b0d3496e
ASL		 631 }\r
632 return hitTime;\r
633 }\r
634\r
635 void selectItem(int idx, boolean addSelection) {\r
636 if (addSelection) {\r
637 if (idx >= 0 && idx < _data._items.length) {\r
638 Item item = (Item) _data._items[idx];\r
639 item._selected = true;\r
640 }\r
641 } else {\r
642 for (int i = 0; i < _data._items.length; i++) {\r
643 Item item = (Item) _data._items[i];\r
644 item._selected = i == idx;\r
645 }\r
646 }\r
647 boolean changed = ensureVisibleItem(idx, true);\r
648 if (!changed)\r
649 redraw();\r
650 }\r
651\r
652 public void selectItem(ITmfTimeAnalysisEntry trace, boolean addSelection) {\r
653 Integer idx = _data.findTraceItemIndex(trace);\r
654 selectItem(idx, addSelection);\r
655 }\r
656\r
657 public int countPerPage() {\r
658 int height = getCtrlSize().y;\r
659 int count = 0;\r
660 if (height > 0)\r
661 count = height / _itemHeight;\r
662 return count;\r
663 }\r
664\r
665 public int getTopIndex() {\r
666 int idx = -1;\r
667 if (_data._items.length > 0)\r
668 idx = 0;\r
669 return idx;\r
670 }\r
671\r
672 public int getBottomIndex() {\r
673 int idx = _data._items.length - 1;\r
674 return idx;\r
675 }\r
676\r
677 Point getCtrlSize() {\r
678 Point size = getSize();\r
79a3a76e
FC		 679 size.x -= getVerticalBar().getSize().x;\r
680 size.y -= getHorizontalBar().getSize().y;\r
b0d3496e
ASL		 681 return size;\r
682 }\r
683\r
684 void getNameRect(Rectangle rect, Rectangle bound, int idx, int nameWidth) {\r
685 idx -= _topItem;\r
686 rect.x = bound.x;\r
687 rect.y = bound.y + idx * _itemHeight;\r
688 rect.width = nameWidth;\r
689 rect.height = _itemHeight;\r
690 }\r
691\r
692 void getStatesRect(Rectangle rect, Rectangle bound, int idx, int nameWidth) {\r
693 idx -= _topItem;\r
694 rect.x = bound.x + nameWidth;\r
695 rect.y = bound.y + idx * _itemHeight;\r
696 rect.width = bound.width - rect.x;\r
697 rect.height = _itemHeight;\r
698 }\r
699\r
700 // private int getTraceNumber(int tid) {\r
701 // int num = -1;\r
702 //\r
703 // Object[] items = _data._items;\r
704 // for (int i = _topItem; i < items.length; i++) {\r
705 // Item item = (Item) items[i];\r
706 // if ((item instanceof TraceItem)) {\r
707 // TsfTmTrace trace = ((TraceItem) item)._trace;\r
708 // if (trace != null && trace.getId() == tid) {\r
709 // num = i;\r
710 // break;\r
711 // }\r
712 // }\r
713 // }\r
714 //\r
715 // return num;\r
716 // }\r
717\r
718 // private void drawArrow(GC gc, int x0, int y0, int x1, int y1, Color c) {\r
719 // gc.setForeground(c);\r
720 // gc.drawLine(x0, y0, x1, y1);\r
721 //\r
722 // if (y1 > y0) {\r
723 // gc.drawLine(x1 - 3, y1 - 3, x1, y1);\r
724 // gc.drawLine(x1 + 3, y1 - 3, x1, y1);\r
725 // } else {\r
726 // gc.drawLine(x1 - 3, y1 + 3, x1, y1);\r
727 // gc.drawLine(x1 + 3, y1 + 3, x1, y1);\r
728 // }\r
729 // }\r
730\r
731 // TODO: CC: used in the removed functionality to draw thread interactions.\r
732 // private void drawTraceThreadEvent(Rectangle bound, TsfTmEvent e,\r
733 // TsfTmTrace trace, int nItem, int color, GC gc) {\r
734 // if (trace == null)\r
735 // return;\r
736 //\r
737 // int tid = trace.getId();\r
738 // if (tid < 0 || getTraceNumber(tid) == -1)\r
739 // return;\r
740 //\r
741 // int nameWidth = _timeProvider.getNameSpace();\r
742 //\r
743 // double time0 = _timeProvider.getTime0();\r
744 // double time1 = _timeProvider.getTime1();\r
745 // if (time0 == time1)\r
746 // return;\r
747 //\r
748 // int xr = bound.x + nameWidth;\r
749 // double K = (double) (bound.width - xr) / (time1 - time0);\r
750 //\r
751 // int x0 = xr + (int) ((e.getTime() - time0) * K);\r
752 // if (x0 < xr)\r
753 // x0 = xr;\r
754 //\r
755 // int x1 = xr + (int) ((trace.getStartTime() - time0) * K);\r
756 // if (x1 < xr)\r
757 // return;\r
758 //\r
759 // int y0 = bound.y + (nItem - _topItem) * _itemHeight + 3\r
760 // + (_itemHeight - 6) / 2;\r
761 // int y1 = bound.y + (getTraceNumber(tid) - _topItem) * _itemHeight + 3\r
762 // + (_itemHeight - 6) / 2;\r
763 //\r
764 // drawArrow(gc, x0, y0, x1, y1, _colors.getColor(color));\r
765 // }\r
766\r
767 public void drawTraceEvent(Rectangle bound, ITimeEvent e, int nItem,\r
768 int color, GC gc) {\r
769 int nameWidth = _timeProvider.getNameSpace();\r
770\r
771 long time0 = _timeProvider.getTime0();\r
772 long time1 = _timeProvider.getTime1();\r
773 if (time0 == time1)\r
774 return;\r
775\r
776 int xr = bound.x + nameWidth;\r
a5823d5f
ASL		 777 double pixelsPerNanoSec = (bound.width - xr <= 2) ? 0\r
778 : (double) (bound.width - xr - 2) / (time1 - time0); // 2 pixels less to make sure end time is visible\r
b0d3496e 779\r
a5823d5f 780 int x0 = xr + (int) ((e.getTime() - time0) * pixelsPerNanoSec);\r
b0d3496e
ASL		 781 if (x0 < xr)\r
782 return;\r
783\r
784 int y0 = bound.y + (nItem - _topItem) * _itemHeight + 3;\r
785\r
786 gc.setBackground(_colors.getColor(color));\r
787 int c[] = { x0 - 3, y0 - 3, x0, y0, x0 + 3, y0 - 3 };\r
788 gc.fillPolygon(c);\r
789 }\r
790\r
791 // TODO: CC:\r
792 // private void drawExecEvent(Rectangle bound, TsfTmTraceExecEventImpl e,\r
793 // int nitem, int color, GC gc) {\r
794 // List runnings = e.getRunningEvents();\r
795 // if (runnings == null)\r
796 // return;\r
797 //\r
798 // int nameWidth = _timeProvider.getNameSpace();\r
799 //\r
800 // double time0 = _timeProvider.getTime0();\r
801 // double time1 = _timeProvider.getTime1();\r
802 // if (time0 == time1)\r
803 // return;\r
804 //\r
805 // int xr = bound.x + nameWidth;\r
806 // double K = (double) (bound.width - xr) / (time1 - time0);\r
807 //\r
808 // int x0 = xr + (int) ((e.getTime() - time0) * K);\r
809 // if (x0 < xr)\r
810 // x0 = xr;\r
811 //\r
812 // Iterator it = runnings.iterator();\r
813 // while (it.hasNext()) {\r
814 // TsfTmTraceRunningEventImpl re = (TsfTmTraceRunningEventImpl) it\r
815 // .next();\r
816 // int tid = re.getThread().getId();\r
817 // if (tid < 0 || getThreadNumber(tid) == -1)\r
818 // continue;\r
819 //\r
820 // int x1 = xr + (int) ((re.getTime() - time0) * K);\r
821 // if (x1 < xr)\r
822 // continue;\r
823 //\r
824 // int y0 = bound.y + (nitem - _topItem) * _itemHeight + 3\r
825 // + (_itemHeight - 6) / 2;\r
826 // int y1 = bound.y + (getThreadNumber(tid) - _topItem) * _itemHeight\r
827 // + 3 + (_itemHeight - 6) / 2;\r
828 //\r
829 // drawArrow(gc, x0, y0, x1, y1, _colors.getColor(color));\r
830 // }\r
831 // }\r
832\r
833 public void drawTraceInteractions(Rectangle bound, GC gc) {\r
834 // int nameWidth = _timeProvider.getNameSpace();\r
835 // Object[] items = _data._items;\r
836 //\r
837 // double time0 = _timeProvider.getTime0();\r
838 // double time1 = _timeProvider.getTime1();\r
839 //\r
840 // if (time0 == time1)\r
841 // return;\r
842 //\r
843 // int xr = bound.x + nameWidth;\r
844 // double K = (double) (bound.width - xr) / (time1 - time0);\r
845\r
846 // for (int i = 0; i < items.length; i++) {\r
847 // Item item = (Item) items[i];\r
848 // if (!(item instanceof TraceItem))\r
849 // continue;\r
850 //\r
851 // TsfTmTrace trace = ((TraceItem) item)._trace;\r
852 // if (trace == null)\r
853 // continue;\r
854 //\r
855 // List<TsfTmEvent> list = trace.getTraceEvents();\r
856 // Iterator<TsfTmEvent> it = list.iterator();\r
857 // while (it.hasNext()) {\r
858 // TsfTmEvent te = (TsfTmEvent) it.next();\r
859 // TODO: CC: Thread Interactions,\r
860 // This needs to be accessed externally via a specific\r
861 // implementation.\r
862 // if (te instanceof TsfTmTraceStartThreadEventImpl) {\r
863 // TsfTmTrace child = ((TsfTmTraceStartThreadEventImpl) te)\r
864 // .getStartedThread();\r
865 // drawThreadThreadEvent(bound, te, child, i,\r
866 // TraceColorScheme.TI_START_THREAD, gc);\r
867 // } else if (te instanceof TsfTmTraceHandoffLockEventImpl) {\r
868 // if (drawThreadReleases)\r
869 // drawExecEvent(bound, (TsfTmTraceExecEventImpl) te, i,\r
870 // TraceColorScheme.TI_HANDOFF_LOCK, gc);\r
871 // } else if (te instanceof TsfTmTraceNotifyAllEventImpl) {\r
872 // if (drawThreadWaits)\r
873 // drawExecEvent(bound, (TsfTmTraceExecEventImpl) te, i,\r
874 // TraceColorScheme.TI_NOTIFY_ALL, gc);\r
875 // } else if (te instanceof TsfTmTraceNotifyEventImpl) {\r
876 // if (drawThreadWaits)\r
877 // drawExecEvent(bound, (TsfTmTraceExecEventImpl) te, i,\r
878 // TraceColorScheme.TI_NOTIFY, gc);\r
879 // } else if (te instanceof\r
880 // TsfTmTraceDeadAndNotifyJoinedEventImpl) {\r
881 // if (drawThreadJoins)\r
882 // drawExecEvent(bound, (TsfTmTraceExecEventImpl) te, i,\r
883 // TraceColorScheme.TI_NOTIFY_JOINED, gc);\r
884 // } else if (te instanceof TsfTmTraceInterruptThreadEventImpl)\r
885 // {\r
886 // if (drawThreadWaits)\r
887 // drawExecEvent(bound, (TsfTmTraceExecEventImpl) te, i,\r
888 // TraceColorScheme.TI_INTERRUPT, gc);\r
889 // } else if (te instanceof\r
890 // TsfTmTraceWaitTimeoutExceedEventImpl) {\r
891 // drawThreadEvent(bound, te, i,\r
892 // TraceColorScheme.TI_WAIT_EXCEEDED, gc);\r
893 // }\r
894 // }\r
895 // }\r
896 }\r
897\r
4e3aa37d 898 @Override\r
b0d3496e 899 void paint(Rectangle bound, PaintEvent e) {\r
a5823d5f
ASL		 900 GC gc = e.gc;\r
901 gc.setBackground(_colors.getColor(TraceColorScheme.BACKGROUND));\r
902 drawBackground(gc, bound.x, bound.y, bound.width, bound.height);\r
b0d3496e
ASL		 903\r
904 if (bound.width < 2 || bound.height < 2 || null == _timeProvider)\r
905 return;\r
906\r
907 _idealNameWidth = 0;\r
908 int nameWidth = _timeProvider.getNameSpace();\r
909 long time0 = _timeProvider.getTime0();\r
910 long time1 = _timeProvider.getTime1();\r
911 long endTime = _timeProvider.getEndTime();\r
912 long selectedTime = _timeProvider.getSelectedTime();\r
913 // draw trace states\r
914 Object[] items = _data._items;\r
915 for (int i = _topItem; i < items.length; i++) {\r
916 Item item = (Item) items[i];\r
6b4f40e9 917 \r
b0d3496e
ASL		 918 getNameRect(_rect0, bound, i, nameWidth);\r
919 if (_rect0.y >= bound.y + bound.height)\r
920 break;\r
921\r
922 if (item instanceof GroupItem) {\r
923 getStatesRect(_rect1, bound, i, nameWidth);\r
924 _rect0.width += _rect1.width;\r
925 drawName(item, _rect0, gc);\r
926 } else {\r
927 drawName(item, _rect0, gc);\r
928 }\r
929 getStatesRect(_rect0, bound, i, nameWidth);\r
930 drawItemDataDurations(item, _rect0, time0, time1, endTime,\r
931 selectedTime, gc);\r
932 }\r
933\r
934 if (drawTracesInteraction)\r
935 drawTraceInteractions(bound, e.gc);\r
936\r
937 // draw drag line, no line if name space is 0.\r
938 if (3 == _dragState) {\r
939 gc.setForeground(_colors.getColor(TraceColorScheme.BLACK));\r
940 gc.drawLine(bound.x + nameWidth, bound.y, bound.x + nameWidth,\r
941 bound.y + bound.height - 1);\r
942 } else if (0 == _dragState && _mouseHover\r
943 && _timeProvider.getNameSpace() > 0) {\r
944 gc.setForeground(_colors.getColor(TraceColorScheme.RED));\r
945 gc.drawLine(bound.x + nameWidth, bound.y, bound.x + nameWidth,\r
946 bound.y + bound.height - 1);\r
947 }\r
948 }\r
949\r
950 void drawName(Item item, Rectangle rect, GC gc) {\r
951 // No name to be drawn\r
952 if (_timeProvider.getNameSpace() == 0)\r
953 return;\r
954 boolean group = item instanceof GroupItem;\r
955\r
956 int elemHeight = rect.height / 2;\r
957 int elemWidth = elemHeight;\r
958 String name = item._name;\r
959 if (group) {\r
960 gc.setBackground(_colors\r
961 .getBkColorGroup(item._selected, _isInFocus));\r
962 gc.fillRectangle(rect);\r
963 if (item._selected && _isInFocus) {\r
964 gc.setForeground(_colors.getBkColor(item._selected, _isInFocus,\r
965 false));\r
966 gc.drawRectangle(rect.x, rect.y, rect.width - 2,\r
967 rect.height - 2);\r
968 }\r
969 gc.setForeground(_colors.getBkColor(false, false, false));\r
970 gc.drawLine(rect.x, rect.y + rect.height - 1, rect.width - 1,\r
971 rect.y + rect.height - 1);\r
972 gc.setForeground(_colors.getFgColorGroup(false, false));\r
973 gc.setBackground(_colors.getBkColor(false, false, false));\r
974 Utils.init(_rect1, rect);\r
975 _rect1.x += MARGIN;\r
976 _rect1.y += (rect.height - elemHeight) / 2;\r
977 _rect1.width = elemWidth;\r
978 _rect1.height = elemHeight;\r
979 // Get the icon rectangle in the group items\r
980 gc.fillRectangle(_rect1);\r
981 gc.drawRectangle(_rect1.x, _rect1.y, _rect1.width - 1,\r
982 _rect1.height - 1);\r
983 int p = _rect1.y + _rect1.height / 2;\r
984 gc.drawLine(_rect1.x + 2, p, _rect1.x + _rect1.width - 3, p);\r
985 if (!item._expanded) {\r
986 p = _rect1.x + _rect1.width / 2;\r
987 gc.drawLine(p, _rect1.y + 2, p, _rect1.y + _rect1.height - 3);\r
988 }\r
989 gc.setForeground(_colors\r
990 .getFgColorGroup(item._selected, _isInFocus));\r
991 elemWidth += MARGIN;\r
992 } else {\r
993 gc.setBackground(_colors.getBkColor(item._selected, _isInFocus,\r
994 true));\r
995 gc.setForeground(_colors.getFgColor(item._selected, _isInFocus));\r
996 gc.fillRectangle(rect);\r
997 Utils.init(_rect1, rect);\r
998 _rect1.x += MARGIN;\r
999 // draw icon\r
1000 ITmfTimeAnalysisEntry trace = ((TraceItem) item)._trace;\r
1001 Image img = utilImpl.getItemImage(trace);\r
1002 if (null != img) {\r
1003 _rect1.y += (rect.height - img.getImageData().height) / 2;\r
1004 gc.drawImage(img, _rect1.x, _rect1.y);\r
1005 }\r
1006 elemWidth = SMALL_ICON_SIZE;\r
1007 // cut long string with "..."\r
1008 Point size = gc.stringExtent(name);\r
1009 if (_idealNameWidth < size.x)\r
1010 _idealNameWidth = size.x;\r
1011 int width = rect.width - MARGIN - MARGIN - elemWidth;\r
1012 int cuts = 0;\r
1013 while (size.x > width && name.length() > 1) {\r
1014 cuts++;\r
1015 name = name.substring(0, name.length() - 1);\r
1016 size = gc.stringExtent(name + "...");\r
1017 }\r
1018 if (cuts > 0)\r
1019 name += "...";\r
1020 elemWidth += MARGIN;\r
1021 }\r
1022 Utils.init(_rect1, rect);\r
1023 int leftMargin = MARGIN + elemWidth;\r
1024 _rect1.x += leftMargin;\r
1025 _rect1.width -= leftMargin;\r
1026 int textWidth = 0;\r
1027 // draw text\r
1028 if (_rect1.width > 0) {\r
1029 _rect1.y += 2;\r
1030 textWidth = Utils.drawText(gc, name, _rect1, true) + 8;\r
1031 _rect1.y -= 2;\r
1032 }\r
1033 // draw middle line\r
1034 if (_rect1.width > 0 && !group) {\r
1035 Utils.init(_rect1, rect);\r
1036 _rect1.x += leftMargin + textWidth;\r
1037 _rect1.width -= textWidth;\r
1038 gc.setForeground(_colors.getColor(TraceColorScheme.MID_LINE));\r
1039 int midy = _rect1.y + _rect1.height / 2;\r
1040 gc.drawLine(_rect1.x, midy, _rect1.x + _rect1.width, midy);\r
1041 }\r
1042 // gc.drawLine(_rect1.x + _rect1.width - 1, _rect1.y, _rect1.x +\r
1043 // _rect1.width - 1, _rect1.y + _rect1.height);\r
1044 }\r
1045\r
1046 void drawItemData(Item item, Rectangle rect, long time0, long time1,\r
1047 long endTime, long selectedTime, GC gc) {\r
1048 if (rect.isEmpty())\r
1049 return;\r
1050 if (time1 <= time0) {\r
1051 gc.setBackground(_colors.getBkColor(false, false, false));\r
1052 gc.fillRectangle(rect);\r
1053 return;\r
1054 }\r
1055\r
1056 Utils.init(_rect1, rect);\r
1057 boolean selected = item._selected;\r
a5823d5f
ASL		 1058 double pixelsPerNanoSec = (rect.width <= 2) ? 0\r
1059 : (double) (rect.width - 2) / (time1 - time0); // 2 pixels less to make sure end time is visible\r
b0d3496e
ASL		 1060 boolean group = item instanceof GroupItem;\r
1061\r
1062 if (group) {\r
1063 // gc.setBackground(_colors.getBkColorGroup(selected, _isInFocus));\r
1064 // gc.fillRectangle(rect);\r
1065 } else if (item instanceof TraceItem) {\r
1066 ITmfTimeAnalysisEntry trace = ((TraceItem) item)._trace;\r
1067\r
1068 int x0 = rect.x;\r
1069 List<TimeEvent> list = trace.getTraceEvents();\r
1070 // Iterator it = list.iterator();\r
1071 int count = list.size();\r
1072 ITimeEvent lastEvent = null;\r
1073 if (count > 0) {\r
1074 ITimeEvent currEvent = list.get(0);\r
1075 ITimeEvent nextEvent = null;\r
1076 long currEventTime = currEvent.getTime();\r
1077 long nextEventTime = currEventTime;\r
a5823d5f
ASL		 1078 x0 = rect.x + (int) ((currEventTime - time0) * pixelsPerNanoSec);\r
1079 int xEnd = rect.x + (int) ((time1 - time0) * pixelsPerNanoSec);\r
b0d3496e
ASL		 1080 int x1 = -1;\r
1081 int idx = 1;\r
1082\r
1083 // reduce rect\r
1084 _rect1.y += 3;\r
1085 _rect1.height -= 6;\r
1086 fillSpace(rect, gc, selected, _rect1.x, x0, xEnd);\r
1087\r
1088 // draw event states\r
1089 while (x0 <= xEnd && null != currEvent) {\r
1090 boolean stopped = false;// currEvent instanceof\r
1091 // TsfTmTraceDeadEvent;\r
1092 if (idx < count) {\r
1093 nextEvent = list.get(idx);\r
1094 nextEventTime = nextEvent.getTime();\r
1095 idx++;\r
1096 } else if (stopped) {\r
1097 nextEvent = null;\r
1098 nextEventTime = time1;\r
1099 } else {\r
1100 nextEvent = null;\r
1101 nextEventTime = endTime;\r
1102 }\r
a5823d5f 1103 x1 = rect.x + (int) ((nextEventTime - time0) * pixelsPerNanoSec);\r
b0d3496e
ASL		 1104 if (x1 >= rect.x) {\r
1105 _rect1.x = x0 >= rect.x ? x0 : rect.x;\r
1106 _rect1.width = (x1 <= xEnd ? x1 : xEnd) - _rect1.x;\r
1107 boolean timeSelected = currEventTime <= selectedTime\r
1108 && selectedTime < nextEventTime;\r
1109 // Trace.debug("Drawing rectangle: " + _rect1.x + ","\r
1110 // + _rect1.y + "," + _rect1.height + ", "\r
1111 // + _rect1.width + "-->"\r
1112 // + ((int) _rect1.x + (int) _rect1.width));\r
1113 utilImpl.drawState(_colors, currEvent, _rect1, gc,\r
1114 selected, false, timeSelected);\r
1115 }\r
1116 lastEvent = currEvent;\r
1117 currEvent = nextEvent;\r
1118 currEventTime = nextEventTime;\r
1119 x0 = x1;\r
1120 }\r
1121 }\r
1122\r
1123 // fill space after last event\r
1124 int xEnd = rect.x + rect.width;\r
1125 if (x0 < xEnd) {\r
1126 _rect1.x = x0 >= rect.x ? x0 : rect.x;\r
1127 _rect1.width = xEnd - _rect1.x;\r
1128 gc.setBackground(_colors\r
1129 .getBkColor(selected, _isInFocus, false));\r
1130 gc.fillRectangle(_rect1);\r
1131 // draw middle line\r
1132 gc.setForeground(_colors.getColor(utilImpl\r
1133 .getEventColorVal(lastEvent)));\r
1134 int midy = _rect1.y + _rect1.height / 2;\r
1135 int lw = gc.getLineWidth();\r
1136 gc.setLineWidth(2);\r
1137 gc.drawLine(_rect1.x, midy, _rect1.x + _rect1.width, midy);\r
1138 gc.setLineWidth(lw);\r
1139 }\r
1140\r
1141 // draw focus ares\r
1142 Utils.init(_rect1, rect);\r
1143 gc.setForeground(_colors.getBkColor(selected, _isInFocus, false));\r
1144 int y = _rect1.y;\r
1145 gc.drawLine(_rect1.x, y, _rect1.x + _rect1.width, y);\r
1146 y++;\r
1147 gc.drawLine(_rect1.x, y, _rect1.x + _rect1.width, y);\r
1148 y++;\r
1149 gc.drawLine(_rect1.x, y, _rect1.x + _rect1.width, y);\r
1150 y = _rect1.y + _rect1.height - 1;\r
1151 gc.drawLine(_rect1.x, y, _rect1.x + _rect1.width, y);\r
1152 y--;\r
1153 gc.drawLine(_rect1.x, y, _rect1.x + _rect1.width, y);\r
1154 y--;\r
1155 gc.drawLine(_rect1.x, y, _rect1.x + _rect1.width, y);\r
1156 }\r
1157\r
1158 // draw selected time\r
a5823d5f 1159 int x = rect.x + (int) ((selectedTime - time0) * pixelsPerNanoSec);\r
b0d3496e
ASL		 1160 if (x >= rect.x && x < rect.x + rect.width) {\r
1161 gc.setForeground(_colors.getColor(TraceColorScheme.SELECTED_TIME));\r
1162 if (group)\r
1163 gc.drawLine(x, rect.y + rect.height - 1, x, rect.y\r
1164 + rect.height);\r
1165 else\r
1166 gc.drawLine(x, rect.y, x, rect.y + rect.height);\r
1167 }\r
1168 }\r
1169\r
1170 /**\r
1171 * Represent the event in series of bursts rather than sequence of states\r
1172 * \r
1173 * @param item\r
1174 * @param rect\r
1175 * - The container rectangle to be colored to different states\r
1176 * @param time0\r
1177 * - Base time of all events\r
1178 * @param time1\r
1179 * - End time of all events\r
1180 * @param endTime\r
1181 * @param selectedTime\r
1182 * @param gc\r
1183 */\r
1184 void drawItemDataBurst(Item item, Rectangle rect, long time0, long time1,\r
1185 long endTime, long selectedTime, GC gc) {\r
1186 if (rect.isEmpty())\r
1187 return;\r
1188 if (time1 <= time0) {\r
1189 gc.setBackground(_colors.getBkColor(false, false, false));\r
1190 gc.fillRectangle(rect);\r
1191 return;\r
1192 }\r
1193\r
1194 // Initialize _rect1 to same values as enclosing rectangle rect\r
1195 Utils.init(_rect1, rect);\r
1196 boolean selected = item._selected;\r
1197 // K pixels per second\r
a5823d5f
ASL		 1198 double pixelsPerNanoSec = (rect.width <= 2) ? 0\r
1199 : (double) (rect.width - 2) / (time1 - time0); // 2 pixels less to make sure end time is visible\r
b0d3496e
ASL		 1200 // Trace.debug("Value of K: " + K + " width:" + rect.width + " time0: "\r
1201 // + time0 + " time1:" + time1 + " endTime: " + endTime);\r
1202\r
1203 boolean group = item instanceof GroupItem;\r
1204\r
1205 if (group) {\r
1206 // gc.setBackground(_colors.getBkColorGroup(selected, _isInFocus));\r
1207 // gc.fillRectangle(rect);\r
1208 // if (Trace.isDEBUG()) {\r
1209 // Trace.debug("Group");\r
1210 // }\r
1211 } else if (item instanceof TraceItem) {\r
1212 ITmfTimeAnalysisEntry trace = ((TraceItem) item)._trace;\r
1213\r
1214 double x0 = rect.x;\r
1215 List<TimeEvent> list = trace.getTraceEvents();\r
1216 // Iterator it = list.iterator();\r
1217 int count = list.size();\r
1218 ITimeEvent lastEvent = null;\r
1219 // Trace.debug("count is: " + count);\r
1220 if (count > 0) {\r
1221 ITimeEvent currEvent = list.get(0);\r
1222 ITimeEvent nextEvent = null;\r
1223 long currEventTime = currEvent.getTime();\r
1224 long nextEventTime = currEventTime;\r
1225 // x0 - Points to the beginning of the event being drawn\r
a5823d5f 1226 double step = (double) ((currEventTime - time0) * pixelsPerNanoSec);\r
b0d3496e
ASL		 1227 x0 = rect.x + step;\r
1228 // xEnd - Points to the end of the events rectangle\r
a5823d5f 1229 double xEnd = rect.x + (double) ((time1 - time0) * pixelsPerNanoSec);\r
b0d3496e
ASL		 1230 double x1 = -1;\r
1231 int idx = 1;\r
1232 double xNext = 0;\r
1233\r
1234 // Drawing rectangle is smaller than reserved space\r
1235 _rect1.y += 3;\r
1236 _rect1.height -= 6;\r
1237\r
1238 // Clean up to empty line to draw on top\r
1239 fillSpace(rect, gc, selected, _rect1.x, xEnd, xEnd);\r
1240 // draw event states\r
1241 while (x0 <= xEnd && null != currEvent) {\r
1242 boolean stopped = false;// currEvent instanceof\r
1243 // TsfTmTraceDeadEvent;\r
1244 if (idx < count) {\r
1245 nextEvent = list.get(idx);\r
1246 nextEventTime = nextEvent.getTime();\r
1247 idx++;\r
1248 } else if (stopped) {\r
1249 nextEvent = null;\r
1250 nextEventTime = time1;\r
1251 } else {\r
1252 nextEvent = null;\r
1253 nextEventTime = endTime;\r
1254 // Trace\r
1255 // .debug("nexEventTime is endTime: "\r
1256 // + nextEventTime);\r
1257 }\r
1258\r
1259 // Draw it as a burst, one unit of width.\r
1260 x1 = x0 + (int) 2;\r
1261 if (x1 >= rect.x && x0 <= xEnd) {\r
1262 // Fill with space until x0\r
1263 _rect1.x = (int) (x0 >= rect.x ? x0 : rect.x);\r
1264 _rect1.width = (int) ((x1 <= xEnd ? x1 : xEnd) - _rect1.x);\r
1265 boolean timeSelected = currEventTime <= selectedTime\r
1266 && selectedTime < nextEventTime;\r
1267 utilImpl.drawState(_colors, currEvent, _rect1, gc,\r
1268 selected, false, timeSelected);\r
1269 // Trace.debug("Drawing rectangle: " + _rect1.x + ","\r
1270 // + _rect1.y + "," + _rect1.height + ", "\r
1271 // + _rect1.width + "-->"\r
1272 // + ((int) _rect1.x + (int) _rect1.width));\r
1273 // Advance rectangle to next start position and Fill\r
1274 // with space until next event\r
1275 _rect1.x += _rect1.width;\r
1276 x0 = x1;\r
a5823d5f 1277 xNext = rect.x + (double) ((nextEventTime - time0) * pixelsPerNanoSec);\r
b0d3496e
ASL		 1278 }\r
1279 // Fill space till next event\r
1280 fillSpace(rect, gc, selected, x0, xNext, xEnd);\r
1281\r
1282 lastEvent = currEvent;\r
1283 currEvent = nextEvent;\r
1284 currEventTime = nextEventTime;\r
1285 // Move x0 to the beginning of next event\r
a5823d5f 1286 x0 = rect.x + (double) ((nextEventTime - time0) * pixelsPerNanoSec);\r
b0d3496e
ASL		 1287 // Trace.debug("rect.x: " + rect.x + " + " +\r
1288 // "(nextEvenTime: "\r
1289 // + nextEventTime + "- time0: " + time0 + ") * K: "\r
1290 // + K + " = " + x0);\r
1291 }\r
1292 }\r
1293\r
1294 // fill space after last event\r
1295 int xEnd = rect.x + rect.width;\r
1296 if (x0 < xEnd) {\r
1297 // Trace.debug("Space after last event, x0: " + x0 + ", xEnd: "\r
1298 // + xEnd);\r
1299 _rect1.x = (int) (x0 >= rect.x ? x0 : rect.x);\r
1300 _rect1.width = xEnd - _rect1.x;\r
1301 gc.setBackground(_colors\r
1302 .getBkColor(selected, _isInFocus, false));\r
1303 gc.fillRectangle(_rect1);\r
1304 // draw middle line\r
1305 gc.setForeground(_colors.getColor(utilImpl\r
1306 .getEventColorVal(lastEvent)));\r
1307 int midy = _rect1.y + _rect1.height / 2;\r
1308 int lw = gc.getLineWidth();\r
1309 gc.setLineWidth(2);\r
1310 gc.drawLine(_rect1.x, midy, _rect1.x + _rect1.width, midy);\r
1311 gc.setLineWidth(lw);\r
1312 }\r
1313\r
1314 // draw focus area\r
1315 Utils.init(_rect1, rect);\r
1316 gc.setForeground(_colors.getBkColor(selected, _isInFocus, false));\r
1317 int y = _rect1.y;\r
1318 gc.drawLine(_rect1.x, y, _rect1.x + _rect1.width, y);\r
1319 y++;\r
1320 gc.drawLine(_rect1.x, y, _rect1.x + _rect1.width, y);\r
1321 y++;\r
1322 gc.drawLine(_rect1.x, y, _rect1.x + _rect1.width, y);\r
1323 y = _rect1.y + _rect1.height - 1;\r
1324 gc.drawLine(_rect1.x, y, _rect1.x + _rect1.width, y);\r
1325 y--;\r
1326 gc.drawLine(_rect1.x, y, _rect1.x + _rect1.width, y);\r
1327 y--;\r
1328 gc.drawLine(_rect1.x, y, _rect1.x + _rect1.width, y);\r
1329 }\r
1330\r
1331 // draw selected time\r
a5823d5f 1332 int x = rect.x + (int) ((selectedTime - time0) * pixelsPerNanoSec);\r
b0d3496e
ASL		 1333 if (x >= rect.x && x < rect.x + rect.width) {\r
1334 gc.setForeground(_colors.getColor(TraceColorScheme.SELECTED_TIME));\r
1335 if (group)\r
1336 gc.drawLine(x, rect.y + rect.height - 1, x, rect.y\r
1337 + rect.height);\r
1338 else\r
1339 gc.drawLine(x, rect.y, x, rect.y + rect.height);\r
1340 }\r
1341 }\r
1342\r
1343 /**\r
1344 * Represent the series of events with specified durations\r
1345 * \r
1346 * @param item\r
1347 * @param rect\r
1348 * - The container rectangle to be colored to different states\r
1349 * @param time0\r
1350 * - Base time of all events - start of visible window\r
1351 * @param time1\r
1352 * - End time of visible events - end time of visible window\r
1353 * @param endTime\r
1354 * - End time of all events - may not be visible in selected\r
1355 * visible window\r
1356 * @param selectedTime\r
1357 * @param gc\r
1358 */\r
1359 void drawItemDataDurations(Item item, Rectangle rect, long time0,\r
1360 long time1, long endTime, long selectedTime, GC gc) {\r
1361 if (rect.isEmpty())\r
1362 return;\r
1363 if (time1 <= time0) {\r
1364 gc.setBackground(_colors.getBkColor(false, false, false));\r
1365 gc.fillRectangle(rect);\r
1366 return;\r
1367 }\r
1368\r
1369 // Initialize _rect1 to same values as enclosing rectangle rect\r
1370 Utils.init(_rect1, rect);\r
1371 boolean selected = item._selected;\r
1372 // K pixels per second\r
a5823d5f
ASL		 1373 double pixelsPerNanoSec = (rect.width <= 2) ? 0\r
1374 : (double) (rect.width - 2) / (time1 - time0); // 2 pixels lesser to make sure end time is visible\r
b0d3496e
ASL		 1375 // Trace.debug("Value of K: " + K + " width:" + rect.width + " time0: "\r
1376 // + time0 + " time1:" + time1 + " endTime: " + endTime);\r
1377\r
1378 boolean group = item instanceof GroupItem;\r
1379\r
1380 if (group) {\r
1381 // gc.setBackground(_colors.getBkColorGroup(selected, _isInFocus));\r
1382 // gc.fillRectangle(rect);\r
1383 } else if (item instanceof TraceItem) {\r
1384 ITmfTimeAnalysisEntry trace = ((TraceItem) item)._trace;\r
1385\r
1386 double x0 = rect.x;\r
1387 List<TimeEvent> list = trace.getTraceEvents();\r
1388 // Iterator it = list.iterator();\r
1389 int count = list.size();\r
a5823d5f 1390 // ITimeEvent lastEvent = null;\r
b0d3496e
ASL		 1391 // if (Trace.isDEBUG()) {\r
1392 // Trace.debug("\n\t\t\tTrace: " + trace.getName()\r
1393 // + utilImpl.getTraceClassName(trace));\r
1394 // }\r
1395 // Trace.debug("count is: " + count);\r
a5823d5f
ASL		 1396 // Drawing rectangle is smaller than reserved space\r
1397 _rect1.y += 3;\r
1398 _rect1.height -= 6;\r
1399\r
1400 // Clean up to empty line to draw on top\r
1401 int xEnd = rect.x + rect.width;\r
1402 fillSpace(rect, gc, selected, _rect1.x, xEnd, xEnd);\r
b0d3496e
ASL		 1403 if (count > 0) {\r
1404 ITimeEvent currEvent = list.get(0);\r
1405 ITimeEvent nextEvent = null;\r
1406 long currEventTime = currEvent.getTime();\r
1407 long currEventDuration = currEvent.getDuration();\r
1408 // initial value\r
1409 long nextEventTime = currEventTime;\r
1410 // x0 - Points to the beginning of the event being drawn\r
a5823d5f 1411 double step = (double) ((currEventTime - time0) * pixelsPerNanoSec);\r
b0d3496e
ASL		 1412 x0 = rect.x + step;\r
1413 // xEnd - Points to the end of the events rectangle\r
1414 double x1 = -1;\r
1415 int idx = 1;\r
1416 double xNext = 0;\r
1417\r
1418 // draw event states\r
a5823d5f 1419 while (/* x0 <= xEnd &&*/ null != currEvent) {\r
b0d3496e
ASL		 1420 boolean stopped = false;// currEvent instanceof\r
1421 // refresh current event duration as the loop moves\r
1422 currEventDuration = currEvent.getDuration();\r
1423 // TsfTmTraceDeadEvent;\r
1424 if (idx < count) {\r
1425 nextEvent = list.get(idx);\r
1426 nextEventTime = nextEvent.getTime();\r
1427 idx++;\r
1428 } else if (stopped) {\r
1429 nextEvent = null;\r
1430 nextEventTime = time1;\r
1431 } else {\r
1432 nextEvent = null;\r
1433 nextEventTime = endTime;\r
1434 // Trace\r
1435 // .debug("nexEventTime is endTime: "\r
1436 // + nextEventTime);\r
1437 }\r
1438\r
1439 // Calculate position to next event\r
a5823d5f 1440 xNext = rect.x + (double) ((nextEventTime - time0) * pixelsPerNanoSec);\r
b0d3496e
ASL		 1441\r
1442 // Calculate end position of current event\r
1443 if (currEventDuration < 0) {\r
a5823d5f
ASL		 1444 x1 = rect.x + (double) ((nextEventTime - time0) * pixelsPerNanoSec);\r
1445 } else if (currEventDuration == 0) {\r
1446 x1 = x0;\r
b0d3496e 1447 } else {\r
a5823d5f 1448 x1 = x0 + (double) ((currEventDuration) * pixelsPerNanoSec);\r
b0d3496e
ASL		 1449 }\r
1450\r
1451 // If event end position x1 further away than start position\r
1452 // of\r
1453 // next event, cut width till next event\r
1454 // Trace.debug("Next Event Pos: " + xNext\r
1455 // + " End Of Current at: " + x1 + " Event Duration: "\r
1456 // + currEventDuration);\r
a5823d5f
ASL		 1457 if (currEventDuration != 0) {\r
1458 x1 = x1 > xNext ? xNext : x1;\r
1459 }\r
b0d3496e
ASL		 1460 // if event end boundary is within time range\r
1461 if (x1 >= rect.x && x0 <= xEnd) {\r
a5823d5f
ASL		 1462 if (currEventDuration != 0) {\r
1463 x0 = (double) (x0 >= rect.x ? x0 : rect.x);\r
1464 } else {\r
1465 x1 = x0 + 2; // make punctual events 2 pixels wide\r
1466 }\r
1467 _rect1.width = (int) Math.round((x1 <= xEnd ? x1 : xEnd) - x0);\r
b0d3496e
ASL		 1468 _rect1.x = (int) x0;\r
1469 boolean timeSelected = currEventTime <= selectedTime\r
1470 && selectedTime < nextEventTime;\r
1471 utilImpl.drawState(_colors, currEvent, _rect1, gc,\r
1472 selected, false, timeSelected);\r
1473 // Trace.debug("Drawing rectangle: " + _rect1.x + ","\r
1474 // + _rect1.y + "," + _rect1.height + ", "\r
1475 // + _rect1.width + "-->"\r
1476 // + ((int) _rect1.x + (int) _rect1.width));\r
1477 // Advance rectangle to next start position and Fill\r
1478 // with space until next event\r
1479 _rect1.x += _rect1.width;\r
1480 x0 = _rect1.x;\r
1481 }\r
1482\r
1483 // Fill space till next event\r
a5823d5f 1484 // fillSpace(rect, gc, selected, x0, xNext, xEnd);\r
b0d3496e 1485\r
a5823d5f 1486 // lastEvent = currEvent;\r
b0d3496e
ASL		 1487 currEvent = nextEvent;\r
1488 currEventTime = nextEventTime;\r
1489 // Move x0 to the beginning of next event\r
a5823d5f 1490 x0 = rect.x + (double) ((nextEventTime - time0) * pixelsPerNanoSec);\r
b0d3496e
ASL		 1491 // Trace.debug("rect.x: " + rect.x + " + " +\r
1492 // "(nextEvenTime: "\r
1493 // + nextEventTime + "- time0: " + time0 + ") * K: "\r
1494 // + K + " = " + x0);\r
1495 }\r
1496 }\r
1497\r
1498 // draw focus area\r
1499 Utils.init(_rect1, rect);\r
1500 gc.setForeground(_colors.getBkColor(selected, _isInFocus, false));\r
1501 int y = _rect1.y;\r
1502 gc.drawLine(_rect1.x, y, _rect1.x + _rect1.width, y);\r
1503 y++;\r
1504 gc.drawLine(_rect1.x, y, _rect1.x + _rect1.width, y);\r
1505 y++;\r
1506 gc.drawLine(_rect1.x, y, _rect1.x + _rect1.width, y);\r
1507 y = _rect1.y + _rect1.height - 1;\r
1508 gc.drawLine(_rect1.x, y, _rect1.x + _rect1.width, y);\r
1509 y--;\r
1510 gc.drawLine(_rect1.x, y, _rect1.x + _rect1.width, y);\r
1511 y--;\r
1512 gc.drawLine(_rect1.x, y, _rect1.x + _rect1.width, y);\r
1513 }\r
1514\r
1515 // draw selected time\r
a5823d5f 1516 int x = rect.x + (int) ((double) (selectedTime - time0) * pixelsPerNanoSec);\r
b0d3496e
ASL		 1517 if (x >= rect.x && x < rect.x + rect.width) {\r
1518 gc.setForeground(_colors.getColor(TraceColorScheme.SELECTED_TIME));\r
1519 if (group)\r
1520 gc.drawLine(x, rect.y + rect.height - 1, x, rect.y\r
1521 + rect.height);\r
1522 else\r
1523 gc.drawLine(x, rect.y, x, rect.y + rect.height);\r
1524 }\r
1525 }\r
1526\r
1527 private void fillSpace(Rectangle rect, GC gc, boolean selected, double x0,\r
1528 double x1, double xEnd) {\r
1529 // fill space before first event\r
1530 if (x0 >= rect.x && x0 < xEnd) {\r
1531 // _rect1.width = (int) ((x1 <= xEnd ? x1 : xEnd) - x0);\r
1532 // Trace.debug("Drawing Space: " + _rect1.x + "," + _rect1.y + ","\r
1533 // + _rect1.height + ", " + _rect1.width + "--> "\r
1534 // + ((int) _rect1.x + (int) _rect1.width));\r
1535\r
1536 // if (_rect1.width < 0) {\r
1537 // Trace.debug("Incorrect width:" + _rect1.width);\r
1538 // }\r
1539 gc.setBackground(_colors.getBkColor(selected, _isInFocus, false));\r
1540 gc.fillRectangle(_rect1);\r
1541 // draw middle line\r
1542 gc.setForeground(_colors.getColor(TraceColorScheme.MID_LINE));\r
1543 int midy = _rect1.y + _rect1.height / 2;\r
1544 gc.drawLine(_rect1.x, midy, _rect1.x + _rect1.width, midy);\r
1545 } else {\r
1546 // Trace.debug("No space added since, x0 is out of range " + x0\r
1547 // + " rect.x: " + rect.x + " xEnd: " + xEnd);\r
1548 }\r
1549 }\r
1550\r
1551 public void keyTraversed(TraverseEvent e) {\r
1552 if ((e.detail == SWT.TRAVERSE_TAB_NEXT)\r
1553 || (e.detail == SWT.TRAVERSE_TAB_PREVIOUS))\r
1554 e.doit = true;\r
1555 }\r
1556\r
1557 public void keyPressed(KeyEvent e) {\r
1558 int idx = -1;\r
1559 if (SWT.HOME == e.keyCode) {\r
1560 idx = getTopIndex();\r
1561 } else if (SWT.END == e.keyCode) {\r
1562 idx = getBottomIndex();\r
1563 } else if (SWT.ARROW_DOWN == e.keyCode) {\r
1564 idx = getSelectedIndex();\r
1565 if (idx < 0)\r
1566 idx = 0;\r
1567 else if (idx < _data._items.length - 1)\r
1568 idx++;\r
1569 } else if (SWT.ARROW_UP == e.keyCode) {\r
1570 idx = getSelectedIndex();\r
1571 if (idx < 0)\r
1572 idx = 0;\r
1573 else if (idx > 0)\r
1574 idx--;\r
1575 } else if (SWT.ARROW_LEFT == e.keyCode) {\r
1576 selectPrevEvent();\r
1577 } else if (SWT.ARROW_RIGHT == e.keyCode) {\r
1578 selectNextEvent();\r
1579 } else if (SWT.PAGE_DOWN == e.keyCode) {\r
1580 int page = countPerPage();\r
1581 idx = getSelectedIndex();\r
1582 if (idx < 0)\r
1583 idx = 0;\r
1584 idx += page;\r
1585 if (idx >= _data._items.length)\r
1586 idx = _data._items.length - 1;\r
1587 } else if (SWT.PAGE_UP == e.keyCode) {\r
1588 int page = countPerPage();\r
1589 idx = getSelectedIndex();\r
1590 if (idx < 0)\r
1591 idx = 0;\r
1592 idx -= page;\r
1593 if (idx < 0)\r
1594 idx = 0;\r
1595 } else if (SWT.CR == e.keyCode) {\r
1596 idx = getSelectedIndex();\r
1597 if (idx >= 0) {\r
1598 if (_data._items[idx] instanceof TraceItem)\r
1599 fireDefaultSelection();\r
1600 else if (_data._items[idx] instanceof GroupItem)\r
1601 toggle(idx);\r
1602 }\r
1603 idx = -1;\r
1604 }\r
1605 if (idx >= 0) {\r
1606 selectItem(idx, false);\r
1607 fireSelectionChanged();\r
1608 }\r
1609 }\r
1610\r
1611 public void keyReleased(KeyEvent e) {\r
1612 }\r
1613\r
1614 public void focusGained(FocusEvent e) {\r
1615 _isInFocus = true;\r
1616 redraw();\r
a5823d5f 1617 getDisplay().addFilter(SWT.MouseWheel, mouseScrollFilterListener);\r
b0d3496e
ASL		 1618 }\r
1619\r
1620 public void focusLost(FocusEvent e) {\r
1621 _isInFocus = false;\r
1622 if (0 != _dragState) {\r
1623 setCapture(false);\r
1624 _dragState = 0;\r
1625 }\r
1626 redraw();\r
a5823d5f 1627 getDisplay().removeFilter(SWT.MouseWheel, mouseScrollFilterListener);\r
b0d3496e
ASL		 1628 }\r
1629\r
1630 public boolean isInFocus() {\r
1631 return _isInFocus;\r
1632 }\r
1633\r
1634 public void mouseMove(MouseEvent e) {\r
1635 if (null == _timeProvider)\r
1636 return;\r
1637 Point size = getCtrlSize();\r
1638 if (1 == _dragState) {\r
1639 int nameWidth = _timeProvider.getNameSpace();\r
1640 int x = e.x - nameWidth;\r
1641 if (x > 0 && size.x > nameWidth && _dragX != x) {\r
1642 _dragX = x;\r
a5823d5f
ASL		 1643 double pixelsPerNanoSec = (size.x - nameWidth <= 2) ? 0\r
1644 : (double) (size.x - nameWidth - 2) / (_time1bak - _time0bak); // 2 pixels less to make sure end time is visible\r
1645 long timeDelta = (long) ((pixelsPerNanoSec == 0) ? 0 : ((_dragX - _dragX0) / pixelsPerNanoSec));\r
b0d3496e
ASL		 1646 long time1 = _time1bak - timeDelta;\r
1647 long maxTime = _timeProvider.getMaxTime();\r
1648 if (time1 > maxTime)\r
1649 time1 = maxTime;\r
1650 long time0 = time1 - (_time1bak - _time0bak);\r
1651 if (time0 < _timeProvider.getMinTime()) {\r
1652 time0 = _timeProvider.getMinTime();\r
1653 time1 = time0 + (_time1bak - _time0bak);\r
1654 }\r
1655 _timeProvider.setStartFinishTime(time0, time1);\r
1656 }\r
1657 } else if (3 == _dragState) {\r
1658 _dragX = e.x;\r
1659 _timeProvider.setNameSpace(_hitIdx + _dragX - _dragX0);\r
1660 } else if (0 == _dragState) {\r
1661 boolean mouseHover = hitSplitTest(e.x, e.y) > 0;\r
1662 if (_mouseHover != mouseHover)\r
1663 redraw();\r
1664 _mouseHover = mouseHover;\r
a5823d5f
ASL		 1665 // Make sure any time changes are notified to the application e.g.\r
1666 // getting back from the horizontal scroll bar or zoomed using the\r
1667 // mouse wheel\r
1668 _timeProvider.setStartFinishTimeNotify(_timeProvider.getTime0(), _timeProvider.getTime1());\r
b0d3496e
ASL		 1669 }\r
1670 updateCursor(e.x, e.y);\r
1671 }\r
1672\r
1673 public void mouseDoubleClick(MouseEvent e) {\r
1674 if (null == _timeProvider)\r
1675 return;\r
1676 if (1 == e.button) {\r
1677 int idx = hitSplitTest(e.x, e.y);\r
1678 if (idx >= 0) {\r
1679 _timeProvider.setNameSpace(_idealNameWidth + 3 * MARGIN\r
1680 + SMALL_ICON_SIZE);\r
1681 return;\r
1682 }\r
1683 idx = hitTest(e.x, e.y);\r
1684 if (idx >= 0) {\r
1685 selectItem(idx, false);\r
1686 if (_data._items[idx] instanceof TraceItem) {\r
1687 fireDefaultSelection();\r
1688 }\r
1689 }\r
1690 }\r
1691 }\r
1692\r
41dc35d0
FC		 1693 /**\r
1694 * <p>\r
1695 * If the x, y position is over the vertical split line (name to time\r
1696 * ranges), then change the cursor to a drag cursor to indicate the user the\r
1697 * possibility of resizing\r
1698 * </p>\r
1699 * \r
1700 * @param x\r
1701 * @param y\r
1702 */\r
b0d3496e 1703 void updateCursor(int x, int y) {\r
41dc35d0
FC		 1704 // if Wait cursor not active, check for the need to change to a drag\r
1705 // cursor\r
1706 if (_isWaitCursor == false) {\r
1707 int idx = hitSplitTest(x, y);\r
1708 // No dragcursor is name space is fixed to zero\r
1709 if (idx > 0 && !_isDragCursor3 && _timeProvider.getNameSpace() > 0) {\r
1710 setCursor(_dragCursor3);\r
1711 _isDragCursor3 = true;\r
1712 } else if (idx <= 0 && _isDragCursor3) {\r
1713 setCursor(null);\r
1714 _isDragCursor3 = false;\r
1715 }\r
1716 }\r
1717 }\r
1718\r
1719 /**\r
1720 * Provide the possibilty to control the wait cursor externally e.g. data\r
1721 * requests in progress\r
1722 * \r
1723 * @param waitInd\r
1724 */\r
1725 public void waitCursor(boolean waitInd) {\r
1726 // Update cursor as indicated\r
1727 if (waitInd) {\r
1728 setCursor(_WaitCursor);\r
1729 _isWaitCursor = true;\r
1730 } else {\r
b0d3496e 1731 setCursor(null);\r
41dc35d0 1732 _isWaitCursor = false;\r
b0d3496e 1733 }\r
41dc35d0
FC		 1734\r
1735 // Get ready for next mouse move\r
1736 _isDragCursor3 = false;\r
b0d3496e
ASL		 1737 }\r
1738\r
1739 public void mouseDown(MouseEvent e) {\r
1740 if (null == _timeProvider)\r
1741 return;\r
1742 int idx;\r
1743 if (1 == e.button) {\r
1744 int namewidth = _timeProvider.getNameSpace();\r
1745 if (namewidth != 0) {\r
1746 idx = hitSplitTest(e.x, e.y);\r
1747 if (idx > 0) {\r
1748 _dragState = 3;\r
1749 _dragX = _dragX0 = e.x;\r
1750 _hitIdx = _timeProvider.getNameSpace();\r
1751 ;\r
1752 _time0bak = _timeProvider.getTime0();\r
1753 _time1bak = _timeProvider.getTime1();\r
1754 redraw();\r
1755 return;\r
1756 }\r
1757 }\r
1758\r
1759 idx = hitTest(e.x, e.y);\r
1760 if (idx >= 0) {\r
1761 if (_data._items[idx] instanceof TraceItem) {\r
1762 long hitTime = hitTimeTest(e.x, e.y);\r
1763 if (hitTime >= 0) {\r
1764 _timeProvider.setSelectedTimeInt(hitTime, false);\r
1765 setCapture(true);\r
1766 _dragState = 1;\r
1767 _dragX = _dragX0 = e.x - _timeProvider.getNameSpace();\r
1768 _time0bak = _timeProvider.getTime0();\r
1769 _time1bak = _timeProvider.getTime1();\r
1770 }\r
1771 } else if (_data._items[idx] instanceof GroupItem) {\r
1772 _hitIdx = idx;\r
1773 _dragState = 2;\r
1774 }\r
1775 selectItem(idx, false);\r
1776 fireSelectionChanged();\r
a5823d5f
ASL		 1777 } else {\r
1778 selectItem(idx, false); // clear selection\r
b0d3496e
ASL		 1779 }\r
1780 }\r
1781 }\r
1782\r
1783 public void mouseUp(MouseEvent e) {\r
1784 if (0 != _dragState) {\r
1785 setCapture(false);\r
79a3a76e 1786 if (2 == _dragState) {\r
b0d3496e
ASL		 1787 if (hitTest(e.x, e.y) == _hitIdx)\r
1788 toggle(_hitIdx);\r
1789 } else if (3 == _dragState) {\r
1790 redraw();\r
1791 }\r
1792 _dragState = 0;\r
1793 }\r
71c964eb
ASL		 1794\r
1795 // Notify time provider to check the need for listener notification\r
a5823d5f 1796 _timeProvider.setStartFinishTimeNotify(_timeProvider.getTime0(), _timeProvider.getTime1());\r
b0d3496e
ASL		 1797 }\r
1798\r
1799 public void controlMoved(ControlEvent e) {\r
1800 }\r
1801\r
1802 public void controlResized(ControlEvent e) {\r
1803 adjustScrolls();\r
1804 }\r
1805\r
1806 public void widgetDefaultSelected(SelectionEvent e) {\r
1807 }\r
1808\r
1809 public void widgetSelected(SelectionEvent e) {\r
1810 if (e.widget == getVerticalBar()) {\r
1811 _topItem = getVerticalBar().getSelection();\r
1812 if (_topItem < 0)\r
1813 _topItem = 0;\r
1814 redraw();\r
1815 } else if (e.widget == getHorizontalBar() && null != _timeProvider) {\r
a5823d5f 1816 int start = getHorizontalBar().getSelection();\r
b0d3496e
ASL		 1817 long time0 = _timeProvider.getTime0();\r
1818 long time1 = _timeProvider.getTime1();\r
1819 long timeMin = _timeProvider.getMinTime();\r
1820 long timeMax = _timeProvider.getMaxTime();\r
1821 long delta = timeMax - timeMin;\r
1822\r
1823 long range = time1 - time0;\r
1824 // _timeRangeFixed = true;\r
a5823d5f 1825 time0 = timeMin + (long) (delta * ((double) start / H_SCROLLBAR_MAX));\r
b0d3496e 1826 time1 = time0 + range;\r
a5823d5f
ASL		 1827\r
1828 // TODO: Follow-up with Bug 310310\r
1829 // In Linux SWT.DRAG is the only value received\r
1830 // https://bugs.eclipse.org/bugs/show_bug.cgi?id=310310\r
1831 if (e.detail == SWT.DRAG) {\r
1832 _timeProvider.setStartFinishTime(time0, time1);\r
1833 } else {\r
1834 _timeProvider.setStartFinishTimeNotify(time0, time1);\r
1835 }\r
b0d3496e
ASL		 1836 }\r
1837 }\r
1838\r
1839 public void mouseEnter(MouseEvent e) {\r
1840 }\r
1841\r
1842 public void mouseExit(MouseEvent e) {\r
1843 if (_mouseHover) {\r
1844 _mouseHover = false;\r
1845 redraw();\r
1846 }\r
1847 }\r
1848\r
1849 public void mouseHover(MouseEvent e) {\r
1850 }\r
1851\r
1852 public void mouseScrolled(MouseEvent e) {\r
a5823d5f
ASL		 1853 if (!_isInFocus)\r
1854 return;\r
b0d3496e 1855 if (e.count > 0) {\r
a5823d5f 1856 zoom(true);\r
b0d3496e 1857 } else if (e.count < 0) {\r
a5823d5f 1858 zoom(false);\r
b0d3496e
ASL		 1859 }\r
1860 }\r
1861\r
1862 public boolean isVisibleVerticalScroll() {\r
1863 return _visibleVerticalScroll;\r
1864 }\r
1865\r
1866 public void setVisibleVerticalScroll(boolean visibleVerticalScroll) {\r
1867 ScrollBar scrollVer = getVerticalBar();\r
1868 if (scrollVer != null) {\r
1869 scrollVer.setVisible(visibleVerticalScroll);\r
1870 }\r
1871 this._visibleVerticalScroll = visibleVerticalScroll;\r
1872 }\r
1873\r
4e3aa37d 1874 @Override\r
b0d3496e
ASL		 1875 public int getBorderWidth() {\r
1876 return _borderWidth;\r
1877 }\r
1878\r
1879 public void setBorderWidth(int borderWidth) {\r
1880 this._borderWidth = borderWidth;\r
1881 }\r
1882\r
1883 public int getHeaderHeight() {\r
1884 return _headerHeight;\r
1885 }\r
1886\r
1887 public void setHeaderHeight(int headerHeight) {\r
1888 this._headerHeight = headerHeight;\r
1889 }\r
1890\r
1891 public int getItemHeight() {\r
1892 return _itemHeight;\r
1893 }\r
1894\r
1895 public void setItemHeight(int rowHeight) {\r
1896 this._itemHeight = rowHeight;\r
1897 }\r
1898\r
1899 public Vector<ITmfTimeAnalysisEntry> getFilteredOut() {\r
1900 return _data.getFilteredOut();\r
1901 }\r
1902\r
1903// @Override\r
1904 public void addSelectionChangedListener(ISelectionChangedListener listener) {\r
1905 if (listener != null) {\r
1906 if (!_selectionChangedListeners.contains(listener)) {\r
1907 _selectionChangedListeners.add(listener);\r
1908 }\r
1909 }\r
1910 }\r
1911\r
1912// @Override\r
1913 public void removeSelectionChangedListener(\r
1914 ISelectionChangedListener listener) {\r
1915 if (listener != null) {\r
1916 _selectionChangedListeners.remove(listener);\r
1917 }\r
1918 }\r
1919\r
1920// @Override\r
1921 public void setSelection(ISelection selection) {\r
1922 if (selection instanceof PlainSelection) {\r
1923 PlainSelection sel = (PlainSelection) selection;\r
1924 Object ob = sel.getFirstElement();\r
1925 if (ob instanceof ITmfTimeAnalysisEntry) {\r
1926 ITmfTimeAnalysisEntry trace = (ITmfTimeAnalysisEntry) ob;\r
1927 selectItem(trace, false);\r
1928 }\r
1929 }\r
1930\r
1931 }\r
1932}\r
1933\r
1934class Item {\r
1935 public boolean _expanded;\r
1936 public boolean _selected;\r
1937 public boolean _hasChildren;\r
1938 public String _name;\r
1939\r
1940 Item(String name) {\r
1941 _name = name;\r
1942 }\r
1943\r
4e3aa37d 1944 @Override\r
b0d3496e
ASL		 1945 public String toString() {\r
1946 return _name;\r
1947 }\r
1948}\r
1949\r
1950class TraceItem extends Item {\r
1951 public ITmfTimeAnalysisEntry _trace;\r
1952\r
1953 TraceItem(ITmfTimeAnalysisEntry trace, String name) {\r
1954 super(name);\r
1955 _trace = trace;\r
1956 }\r
1957}\r
1958\r
1959class GroupItem extends Item {\r
1960 public List<ITmfTimeAnalysisEntry> _traces;\r
1961\r
1962 GroupItem(String name) {\r
1963 super(name);\r
1964 _traces = new ArrayList<ITmfTimeAnalysisEntry>();\r
1965 _hasChildren = true;\r
1966 }\r
1967\r
1968 void add(ITmfTimeAnalysisEntry trace) {\r
1969 _traces.add(trace);\r
1970 }\r
1971}\r
1972\r
1973class ItemData {\r
1974 public Object[] _items = new Object[0];\r
1975 private Object _traces[] = new Object[0];\r
1976 private boolean traceFilter[] = new boolean[0];\r
1977 private Map<String, GroupItem> _groupTable = new HashMap<String, GroupItem>();\r
1978 private boolean _flatList = false;\r
1979 private TmfTimeAnalysisProvider utilsImp;\r
1980 private Vector<ITmfTimeAnalysisEntry> filteredOut = new Vector<ITmfTimeAnalysisEntry>();\r
1981\r
1982 public ItemData(TmfTimeAnalysisProvider utils) {\r
1983 this.utilsImp = utils;\r
1984 }\r
1985\r
1986 protected void groupTraces(boolean on) {\r
1987 if (_flatList == on) {\r
1988 _flatList = !on;\r
1989 updateItems();\r
1990 }\r
1991 }\r
1992\r
1993 void clearGroups() {\r
1994 Iterator<GroupItem> it = _groupTable.values().iterator();\r
1995 while (it.hasNext()) {\r
1996 GroupItem group = it.next();\r
1997 group._traces.clear();\r
1998 }\r
1999 }\r
2000\r
2001 void deleteEmptyGroups() {\r
2002 Iterator<GroupItem> it = _groupTable.values().iterator();\r
2003 while (it.hasNext()) {\r
2004 GroupItem group = it.next();\r
2005 if (group._traces.size() == 0)\r
2006 it.remove();\r
2007 }\r
2008 }\r
2009\r
2010 TraceItem findTraceItem(ITmfTimeAnalysisEntry trace) {\r
2011 if (trace == null)\r
2012 return null;\r
2013\r
2014 int traceId = trace.getId();\r
2015 TraceItem traceItem = null;\r
2016\r
2017 for (int i = 0; i < _items.length; i++) {\r
2018 Object item = _items[i];\r
2019 if (item instanceof TraceItem) {\r
2020 TraceItem ti = (TraceItem) item;\r
2021 if (ti._trace.getId() == traceId) {\r
2022 traceItem = ti;\r
2023 break;\r
2024 }\r
2025 }\r
2026 }\r
2027\r
2028 return traceItem;\r
2029 }\r
2030\r
2031 Integer findTraceItemIndex(ITmfTimeAnalysisEntry trace) {\r
2032 if (trace == null)\r
2033 return null;\r
2034\r
2035 int traceId = trace.getId();\r
2036\r
2037 Integer idx = null;\r
2038 for (int i = 0; i < _items.length; i++) {\r
2039 idx = i;\r
2040 Object item = _items[i];\r
2041 if (item instanceof TraceItem) {\r
2042 TraceItem ti = (TraceItem) item;\r
2043 if (ti._trace.getId() == traceId) {\r
2044 break;\r
2045 }\r
2046 }\r
2047 }\r
2048\r
2049 return idx;\r
2050 }\r
2051\r
2052 public void updateItems() {\r
2053 List<Item> itemList = new ArrayList<Item>();\r
2054 String name = "";\r
2055\r
2056 Iterator<GroupItem> it = _groupTable.values().iterator();\r
2057 while (it.hasNext()) {\r
2058 GroupItem group = it.next();\r
2059 if (!_flatList)\r
2060 itemList.add(group);\r
2061\r
2062 if (_flatList || group._expanded) {\r
2063 Iterator<ITmfTimeAnalysisEntry> it2 = group._traces.iterator();\r
2064 while (it2.hasNext()) {\r
2065 ITmfTimeAnalysisEntry trace = it2.next();\r
2066 TraceItem traceItem = findTraceItem(trace);\r
2067 name = utilsImp.composeTraceName(trace, false);\r
2068 traceItem = new TraceItem(trace, name);\r
2069 itemList.add(traceItem);\r
2070 }\r
2071 }\r
2072 }\r
2073 _items = itemList.toArray();\r
2074 }\r
2075\r
2076 public int expandItem(int idx, boolean expand) {\r
2077 if (idx < 0 || idx >= _items.length)\r
2078 return 0;\r
2079 int ret = 0;\r
2080 Item item = (Item) _items[idx];\r
2081 if (item._hasChildren && !item._expanded) {\r
2082 item._expanded = expand;\r
2083 ret = _items.length;\r
2084 updateItems();\r
2085 ret = _items.length - ret;\r
2086 }\r
2087 return ret;\r
2088 }\r
2089\r
2090 public void refreshData(Object traces[]) {\r
2091 if (traces == null || traces.length == 0) {\r
2092 traceFilter = null;\r
2093 } else if (traceFilter == null || traces.length != traceFilter.length) {\r
2094 traceFilter = new boolean[traces.length];\r
2095 java.util.Arrays.fill(traceFilter, true);\r
2096 }\r
2097\r
2098 _traces = traces;\r
2099 refreshData();\r
2100 }\r
2101\r
2102 /**\r
2103 * Allows to update the GUI from a stream of events handling addition one by\r
2104 * one over known TmfTaTrace parents.\r
2105 * \r
2106 * @param parent\r
2107 * @param childItem\r
2108 */\r
2109 public void refreshPartial(ITmfTimeAnalysisEntry parent, TimeEvent childItem) {\r
2110 // Find the Trace item within the current list\r
2111 TraceItem item = findTraceItem(parent);\r
2112\r
bbeafe9d
FC		 2113// This method is not used (yet) so this code can be commented out for now\r
2114// FIXME: Arrays.copyOf is a Java6 feature\r
2115// if (item == null) {\r
2116// // If the parent item is not found, make room for it in the current\r
2117// // array\r
2118// int length = 1;\r
2119// Object[] traces;\r
2120// if (_traces != null) {\r
2121// length = _traces.length + 1;\r
2122// traces = Arrays.copyOf(_traces, length);\r
2123// } else {\r
2124// traces = new Object[length];\r
2125// }\r
2126//\r
2127// // Add the new parent element to the end of the array.\r
2128// traces[length - 1] = parent;\r
2129//\r
2130// // update the filter array to accomodate a postion to the new\r
2131// // element\r
2132// traceFilter = new boolean[traces.length];\r
2133// java.util.Arrays.fill(traceFilter, true);\r
2134//\r
2135// // rebuild internal data\r
2136// _traces = traces;\r
2137// refreshData();\r
2138//\r
2139// // item must be there\r
2140// item = findTraceItem(parent);\r
2141// }\r
b0d3496e
ASL		 2142\r
2143 ITmfTimeAnalysisEntry localTraceItem = item._trace;\r
2144 // Local trace found\r
2145 Vector<TimeEvent> children = localTraceItem.getTraceEvents();\r
2146 TimeEvent lastChildIn = children.lastElement();\r
2147 long lastChildSTime = lastChildIn.getTime();\r
2148 long newChildSTime = childItem.getTime();\r
2149 if (newChildSTime < lastChildSTime) {\r
2150 // The children are expected to arrive sorted by time\r
2151 // since the new time is earlier than the last child\r
2152 // The infomation is being refreshed from start, remove all\r
2153 // children and start over\r
2154 children.clear();\r
2155 }\r
2156 // Add the new item\r
2157 children.add(childItem);\r
2158\r
2159 }\r
2160\r
2161 public void refreshData() {\r
2162 clearGroups();\r
2163 filteredOut.clear();\r
2164 String undef = Messages._UNDEFINED_GROUP;\r
2165 List<GroupItem> groupList = new ArrayList<GroupItem>();\r
2166 for (int i = 0; i < _traces.length; i++) {\r
2167 ITmfTimeAnalysisEntry trace = (ITmfTimeAnalysisEntry) _traces[i];\r
2168 if (!traceFilter[i]) {\r
2169 filteredOut.add(trace);\r
2170 continue;\r
2171 }\r
2172\r
2173 String groupName = trace.getGroupName();\r
2174 if (null == groupName)\r
2175 groupName = undef;\r
2176\r
2177 GroupItem group = _groupTable.get(groupName);\r
2178 if (null == group) {\r
2179 group = new GroupItem(NLS.bind(Messages._TRACE_GROUP_LABEL,\r
2180 groupName));\r
2181 group._expanded = !groupName.equalsIgnoreCase("system")\r
2182 && !groupName.equalsIgnoreCase(undef);\r
2183 _groupTable.put(groupName, group);\r
2184 groupList.add(group);\r
2185 }\r
2186 group.add(trace);\r
2187 }\r
2188\r
2189 deleteEmptyGroups();\r
2190 updateItems();\r
2191 }\r
2192\r
2193 public Object[] getTraces() {\r
2194 return _traces;\r
2195 }\r
2196\r
2197 public boolean[] getTraceFilter() {\r
2198 return traceFilter;\r
2199 }\r
2200\r
2201 public Vector<ITmfTimeAnalysisEntry> getFilteredOut() {\r
2202 return filteredOut;\r
2203 }\r
2204}\r
Tracecompass - Deliverables
This page took 0.235734 seconds and 5 git commands to generate.