Attachment #178665 for bug #325016

Some Eclipse Foundation services are deprecated, or will be soon. Please ensure you've read this important communication.

Lines 23-27 Link Here

(-)META-INF/MANIFEST.MF (+1 lines)
23	org.eclipse.linuxtools.tmf.ui.viewers.timeAnalysis.widgets,	23	org.eclipse.linuxtools.tmf.ui.viewers.timeAnalysis.widgets,
24	org.eclipse.linuxtools.tmf.ui.views,	24	org.eclipse.linuxtools.tmf.ui.views,
25	org.eclipse.linuxtools.tmf.ui.views.project,	25	org.eclipse.linuxtools.tmf.ui.views.project,
		26	org.eclipse.linuxtools.tmf.ui.views.timechart,
26	org.eclipse.linuxtools.tmf.ui.widgets	27	org.eclipse.linuxtools.tmf.ui.widgets
27	Bundle-Localization: plugin	28	Bundle-Localization: plugin

Lines 274-279 Link Here

(-)src/org/eclipse/linuxtools/tmf/ui/viewers/timeAnalysis/TmfTimeAnalysisProvider.java (+3 lines)
274	if (threadClass != null && threadClass.length() > 0) {	274	if (threadClass != null && threadClass.length() > 0) {
275	name += " [" + threadClass + "]";	275	name += " [" + threadClass + "]";
276	}	276	}
		277	/*
		278	* Check if this is still necessary!
277	if (inclState) {	279	if (inclState) {
278	List<TimeEvent> list = trace.getTraceEvents();	280	List<TimeEvent> list = trace.getTraceEvents();
279	if (null != list && list.size() > 0) {	281	if (null != list && list.size() > 0) {
Lines 281-286 Link Here
281	name += " (" + getEventName(event, false, true) + ")";	283	name += " (" + getEventName(event, false, true) + ")";
282	}	284	}
283	}	285	}
		286	*/
284	return name;	287	return name;
285	}	288	}
286		289

Lines 107-113 Link Here

(-)src/org/eclipse/linuxtools/tmf/ui/viewers/timeAnalysis/TmfTimeAnalysisViewer.java (-2 / +11 lines)
107	// called from the display order in the API	107	// called from the display order in the API
108	public void modelUpdate(ITmfTimeAnalysisEntry[] traces) {	108	public void modelUpdate(ITmfTimeAnalysisEntry[] traces) {
109	if (null != _stateCtrl) {	109	if (null != _stateCtrl) {
110	loadOptions();	110	//loadOptions();
111	updateInternalData(traces);	111	updateInternalData(traces);
112	_stateCtrl.redraw();	112	_stateCtrl.redraw();
113	_timeScaleCtrl.redraw();	113	_timeScaleCtrl.redraw();
Lines 118-124 Link Here
118	public void modelUpdate(ITmfTimeAnalysisEntry[] traces, long start,	118	public void modelUpdate(ITmfTimeAnalysisEntry[] traces, long start,
119	long end, boolean updateTimeBounds) {	119	long end, boolean updateTimeBounds) {
120	if (null != _stateCtrl) {	120	if (null != _stateCtrl) {
121	loadOptions();	121	//loadOptions();
122	updateInternalData(traces, start, end);	122	updateInternalData(traces, start, end);
123	if (updateTimeBounds) {	123	if (updateTimeBounds) {
124	_timeRangeFixed = true;	124	_timeRangeFixed = true;
Lines 236-241 Link Here
236	_endTime = entry.getStopTime();	236	_endTime = entry.getStopTime();
237	}	237	}
238	}	238	}
		239	/*
		240	* This is not needed if entry startTime and stopTime are properly set!
239	List<TimeEvent> list = entry.getTraceEvents();	241	List<TimeEvent> list = entry.getTraceEvents();
240	int len = list.size();	242	int len = list.size();
241	if (len > 0) {	243	if (len > 0) {
Lines 249-254 Link Here
249	_endTime = eventEndTime;	251	_endTime = eventEndTime;
250	}	252	}
251	}	253	}
		254	*/
252	}	255	}
253		256
254	if (_beginTime < 0)	257	if (_beginTime < 0)
Lines 764-769 Link Here
764	}	767	}
765	}	768	}
766		769
		770	public void setMinimumItemWidth(int width) {
		771	if (_stateCtrl != null) {
		772	_stateCtrl.setMinimumItemWidth(width);
		773	}
		774	}
		775
767	public boolean isVisibleVerticalScroll() {	776	public boolean isVisibleVerticalScroll() {
768	if (_stateCtrl != null) {	777	if (_stateCtrl != null) {
769	_stateCtrl.isVisibleVerticalScroll();	778	_stateCtrl.isVisibleVerticalScroll();





public abstract class TimeEvent implements ITimeEvent {
	/* (non-Javadoc)
	 * @see org.eclipse.linuxtools.tmf.ui.viewers.timeAnalysis.model.ITimeEvent#getTrace()
	 */
	public abstract ITmfTimeAnalysisEntry getEntry();
	
	/* (non-Javadoc)
	 * @see org.eclipse.linuxtools.tmf.ui.viewers.timeAnalysis.model.ITimeEvent#getTime()
	 */
	public abstract long getTime();
	
	/* (non-Javadoc)
	 * @see org.eclipse.linuxtools.tmf.ui.viewers.timeAnalysis.model.ITimeEvent#getDuration()
	 */
	public long getDuration() {
		return -1;





package org.eclipse.linuxtools.tmf.ui.viewers.timeAnalysis.model;

import java.util.Iterator;
import java.util.Vector;

public interface ITmfTimeAnalysisEntry {


	public long getStopTime();

    /**
     * Get a vector containing all events
     * @deprecated replaced by {@link #getTraceEventsIterator()}
     */
    @Deprecated public <T extends ITimeEvent> Vector<T> getTraceEvents();
    
    /**
     * Get an iterator which returns all events
     */
    public <T extends ITimeEvent> Iterator<T> getTraceEventsIterator();
    
    /**
     * Get an iterator which only returns events that fall within the start time and the stop time.
     * The visible duration is the event duration below which further detail is not discernible.
     * If no such iterator is implemented, provide a basic iterator which returns all events.
     * 
     * @param startTime start time in nanoseconds
     * @param stopTime stop time in nanoseconds
     * @param visibleDuration duration of one pixel in nanoseconds
     */
    public <T extends ITimeEvent> Iterator<T> getTraceEventsIterator(long startTime, long stopTime, long visibleDuration);
    
    public <T extends ITimeEvent> void addTraceEvent(T event);
}




TRACE_STATES_TITLE = States Transition Visualizer

# labels
_TRACE_ID = Trace Id
_TRACE_DATE = Date
_TRACE_NAME = Trace Name
_TRACE_CLASS_NAME = Class Name
_TRACE_GROUP_NAME = Group Name
_TRACE_START_TIME = Start Time

_TRACE_STOP_TIME = Stop Time
_DURATION = Duration
_TRACE_STATE = State
_NUMBER_OF_TRACES = Number of traces
_TRACE_FILTER = Trace Filter
_TRACE_FILTER_DESC = Define the filter set
_Timescale = Time scale
_UNDEFINED_GROUP = <undefined>
_TRACE_GROUP_LABEL = Trace Group [{0}]
_EDIT_PROFILING_OPTIONS = Edit Profiling Options

#Monitor statistics view messages
# MEM_ALLOCATION_DETAILS_FOR = Allocation details for
_LEGEND = Legend
_TRACE_STATES = Trace states
_WINDOW_TITLE = Trace Visualizer's Legend

Lines 126-131 Link Here

(-)src/org/eclipse/linuxtools/tmf/ui/viewers/timeAnalysis/ITimeAnalysisViewer.java (+2 lines)
126		126
127	public void setItemHeight(int rowHeight);	127	public void setItemHeight(int rowHeight);
128		128
		129	public void setMinimumItemWidth(int width);
		130
129	public void resizeControls();	131	public void resizeControls();
130		132
131	public void setSelectedTrace(ITmfTimeAnalysisEntry trace);	133	public void setSelectedTrace(ITmfTimeAnalysisEntry trace);

Lines 67-73 Link Here

(-)src/org/eclipse/linuxtools/tmf/ui/viewers/timeAnalysis/widgets/TmfTimeStatesCtrl.java (-68 / +99 lines)
67	ControlListener, SelectionListener, MouseTrackListener,	67	ControlListener, SelectionListener, MouseTrackListener,
68	TraverseListener, ISelectionProvider {	68	TraverseListener, ISelectionProvider {
69		69
70	public static final boolean DEFAULT_DRAW_THREAD_JOIN = true;	70	private static final int DRAG_NONE = 0;
		71	private static final int DRAG_TRACE_ITEM = 1;
		72	private static final int DRAG_GROUP_ITEM = 2;
		73	private static final int DRAG_SPLIT_LINE = 3;
		74	public static final boolean DEFAULT_DRAW_THREAD_JOIN = true;
71	public static final boolean DEFAULT_DRAW_THREAD_WAIT = true;	75	public static final boolean DEFAULT_DRAW_THREAD_WAIT = true;
72	public static final boolean DEFAULT_DRAW_THREAD_RELEASE = true;	76	public static final boolean DEFAULT_DRAW_THREAD_RELEASE = true;
73	public static int H_SCROLLBAR_MAX = Integer.MAX_VALUE - 1;	77	public static int H_SCROLLBAR_MAX = Integer.MAX_VALUE - 1;
Lines 81-88 Link Here
81	private boolean _mouseHover = false;	85	private boolean _mouseHover = false;
82	private int _itemHeightDefault = 19;	86	private int _itemHeightDefault = 19;
83	private int _itemHeight = _itemHeightDefault;	87	private int _itemHeight = _itemHeightDefault;
		88	private int _minimumItemWidth = 0;
84	private int _topItem = 0;	89	private int _topItem = 0;
85	private int _dragState = 0;	90	private int _dragState = DRAG_NONE;
86	private int _hitIdx = 0;	91	private int _hitIdx = 0;
87	private int _dragX0 = 0;	92	private int _dragX0 = 0;
88	private int _dragX = 0;	93	private int _dragX = 0;
Lines 137-149 Link Here
137	if (scrollHor != null) {	142	if (scrollHor != null) {
138	scrollHor.addSelectionListener(this);	143	scrollHor.addSelectionListener(this);
139	}	144	}
140	mouseScrollFilterListener = new Listener() {
141	// This filter is used to prevent scrolling of the view when the
142	// mouse wheel is used to zoom
143	public void handleEvent(Event event) {
144	event.doit = false;
145	}
146	};
147		145
148	_dragCursor3 = new Cursor(super.getDisplay(), SWT.CURSOR_SIZEWE);	146	_dragCursor3 = new Cursor(super.getDisplay(), SWT.CURSOR_SIZEWE);
149	_WaitCursor = new Cursor(super.getDisplay(), SWT.CURSOR_WAIT);	147	_WaitCursor = new Cursor(super.getDisplay(), SWT.CURSOR_WAIT);
Lines 455-461 Link Here
455	if (zoomIn) {	453	if (zoomIn) {
456	newInterval = Math.max(Math.round((double) interval * 0.8), _timeProvider.getMinTimeInterval());	454	newInterval = Math.max(Math.round((double) interval * 0.8), _timeProvider.getMinTimeInterval());
457	} else {	455	} else {
458	newInterval = Math.round((double) interval * 1.25);	456	newInterval = (long) Math.ceil((double) interval * 1.25);
459	}	457	}
460	long center = time0 + Math.round(((double) (xPos - nameSpace) / timeSpace * interval));	458	long center = time0 + Math.round(((double) (xPos - nameSpace) / timeSpace * interval));
461	long newTime0 = center - Math.round((double) newInterval * (center - time0) / interval);	459	long newTime0 = center - Math.round((double) newInterval * (center - time0) / interval);
Lines 631-637 Link Here
631	return idx >= 0 ? (Item) _data._items[idx] : null;	629	return idx >= 0 ? (Item) _data._items[idx] : null;
632	}	630	}
633		631
634	long hitTimeTest(int x, int y) {	632	long hitTimeTest(int x) {
635	if (null == _timeProvider)	633	if (null == _timeProvider)
636	return -1;	634	return -1;
637	long hitTime = -1;	635	long hitTime = -1;
Lines 653-677 Link Here
653	}	651	}
654		652
655	void selectItem(int idx, boolean addSelection) {	653	void selectItem(int idx, boolean addSelection) {
		654	boolean changed = false;
656	if (addSelection) {	655	if (addSelection) {
657	if (idx >= 0 && idx < _data._items.length) {	656	if (idx >= 0 && idx < _data._items.length) {
658	Item item = (Item) _data._items[idx];	657	Item item = (Item) _data._items[idx];
		658	changed = (item._selected == false);
659	item._selected = true;	659	item._selected = true;
660	}	660	}
661	} else {	661	} else {
662	for (int i = 0; i < _data._items.length; i++) {	662	for (int i = 0; i < _data._items.length; i++) {
663	Item item = (Item) _data._items[i];	663	Item item = (Item) _data._items[i];
		664	if (i == idx && item._selected == false) {
		665	changed = true;
		666	}
664	item._selected = i == idx;	667	item._selected = i == idx;
665	}	668	}
666	}	669	}
667	boolean changed = ensureVisibleItem(idx, true);	670	changed \|= ensureVisibleItem(idx, true);
668	if (!changed)	671	if (changed)
669	redraw();	672	redraw();
670	}	673	}
671		674
672	public void selectItem(ITmfTimeAnalysisEntry trace, boolean addSelection) {	675	public void selectItem(ITmfTimeAnalysisEntry trace, boolean addSelection) {
673	Integer idx = _data.findTraceItemIndex(trace);	676	Integer idx = _data.findTraceItemIndex(trace);
674	selectItem(idx, addSelection);	677	if (idx != null) {
		678	selectItem(idx, addSelection);
		679	}
675	}	680	}
676		681
677	public int countPerPage() {	682	public int countPerPage() {
Lines 958-969 Link Here
958	if (drawTracesInteraction)	963	if (drawTracesInteraction)
959	drawTraceInteractions(bound, e.gc);	964	drawTraceInteractions(bound, e.gc);
960		965
		966	// draw empty name space background
		967	if (_itemHeight * items.length < bound.height) {
		968	gc.setBackground(_colors.getBkColor(false, false, true));
		969	drawBackground(gc, bound.x, _itemHeight * items.length, nameWidth, bound.height - _itemHeight * items.length);
		970	}
		971
961	// draw drag line, no line if name space is 0.	972	// draw drag line, no line if name space is 0.
962	if (3 == _dragState) {	973	if (DRAG_SPLIT_LINE == _dragState) {
963	gc.setForeground(_colors.getColor(TraceColorScheme.BLACK));	974	gc.setForeground(_colors.getColor(TraceColorScheme.BLACK));
964	gc.drawLine(bound.x + nameWidth, bound.y, bound.x + nameWidth,	975	gc.drawLine(bound.x + nameWidth, bound.y, bound.x + nameWidth,
965	bound.y + bound.height - 1);	976	bound.y + bound.height - 1);
966	} else if (0 == _dragState && _mouseHover	977	} else if (DRAG_NONE == _dragState && _mouseHover
967	&& _timeProvider.getNameSpace() > 0) {	978	&& _timeProvider.getNameSpace() > 0) {
968	gc.setForeground(_colors.getColor(TraceColorScheme.RED));	979	gc.setForeground(_colors.getColor(TraceColorScheme.RED));
969	gc.drawLine(bound.x + nameWidth, bound.y, bound.x + nameWidth,	980	gc.drawLine(bound.x + nameWidth, bound.y, bound.x + nameWidth,
Lines 1090-1101 Link Here
1090	ITmfTimeAnalysisEntry trace = ((TraceItem) item)._trace;	1101	ITmfTimeAnalysisEntry trace = ((TraceItem) item)._trace;
1091		1102
1092	int x0 = rect.x;	1103	int x0 = rect.x;
1093	List<TimeEvent> list = trace.getTraceEvents();	1104	Iterator<ITimeEvent> iterator = trace.getTraceEventsIterator();
1094	// Iterator it = list.iterator();
1095	int count = list.size();
1096	ITimeEvent lastEvent = null;	1105	ITimeEvent lastEvent = null;
1097	if (count > 0) {	1106	if (iterator.hasNext()) {
1098	ITimeEvent currEvent = list.get(0);	1107	ITimeEvent currEvent = iterator.next();
1099	ITimeEvent nextEvent = null;	1108	ITimeEvent nextEvent = null;
1100	long currEventTime = currEvent.getTime();	1109	long currEventTime = currEvent.getTime();
1101	long nextEventTime = currEventTime;	1110	long nextEventTime = currEventTime;
Lines 1113-1120 Link Here
1113	while (x0 <= xEnd && null != currEvent) {	1122	while (x0 <= xEnd && null != currEvent) {
1114	boolean stopped = false;// currEvent instanceof	1123	boolean stopped = false;// currEvent instanceof
1115	// TsfTmTraceDeadEvent;	1124	// TsfTmTraceDeadEvent;
1116	if (idx < count) {	1125	if (iterator.hasNext()) {
1117	nextEvent = list.get(idx);	1126	nextEvent = iterator.next();
1118	nextEventTime = nextEvent.getTime();	1127	nextEventTime = nextEvent.getTime();
1119	idx++;	1128	idx++;
1120	} else if (stopped) {	1129	} else if (stopped) {
Lines 1236-1248 Link Here
1236	ITmfTimeAnalysisEntry trace = ((TraceItem) item)._trace;	1245	ITmfTimeAnalysisEntry trace = ((TraceItem) item)._trace;
1237		1246
1238	double x0 = rect.x;	1247	double x0 = rect.x;
1239	List<TimeEvent> list = trace.getTraceEvents();	1248	Iterator<ITimeEvent> iterator = trace.getTraceEventsIterator();
1240	// Iterator it = list.iterator();
1241	int count = list.size();
1242	ITimeEvent lastEvent = null;	1249	ITimeEvent lastEvent = null;
1243	// Trace.debug("count is: " + count);	1250	// Trace.debug("count is: " + count);
1244	if (count > 0) {	1251	if (iterator.hasNext()) {
1245	ITimeEvent currEvent = list.get(0);	1252	ITimeEvent currEvent = iterator.next();
1246	ITimeEvent nextEvent = null;	1253	ITimeEvent nextEvent = null;
1247	long currEventTime = currEvent.getTime();	1254	long currEventTime = currEvent.getTime();
1248	long nextEventTime = currEventTime;	1255	long nextEventTime = currEventTime;
Lines 1265-1272 Link Here
1265	while (x0 <= xEnd && null != currEvent) {	1272	while (x0 <= xEnd && null != currEvent) {
1266	boolean stopped = false;// currEvent instanceof	1273	boolean stopped = false;// currEvent instanceof
1267	// TsfTmTraceDeadEvent;	1274	// TsfTmTraceDeadEvent;
1268	if (idx < count) {	1275	if (iterator.hasNext()) {
1269	nextEvent = list.get(idx);	1276	nextEvent = iterator.next();
1270	nextEventTime = nextEvent.getTime();	1277	nextEventTime = nextEvent.getTime();
1271	idx++;	1278	idx++;
1272	} else if (stopped) {	1279	} else if (stopped) {
Lines 1408-1416 Link Here
1408	ITmfTimeAnalysisEntry trace = ((TraceItem) item)._trace;	1415	ITmfTimeAnalysisEntry trace = ((TraceItem) item)._trace;
1409		1416
1410	double x0 = rect.x;	1417	double x0 = rect.x;
1411	List<TimeEvent> list = trace.getTraceEvents();	1418	long maxDuration = (_timeProvider.getTimeSpace() == 0) ? Long.MAX_VALUE : 1 * (_timeProvider.getTime1() - _timeProvider.getTime0()) / _timeProvider.getTimeSpace();
1412	// Iterator it = list.iterator();	1419	Iterator<ITimeEvent> iterator = trace.getTraceEventsIterator(_timeProvider.getTime0(), _timeProvider.getTime1(), maxDuration);
1413	int count = list.size();
1414	// ITimeEvent lastEvent = null;	1420	// ITimeEvent lastEvent = null;
1415	// if (Trace.isDEBUG()) {	1421	// if (Trace.isDEBUG()) {
1416	// Trace.debug("\n\t\t\tTrace: " + trace.getName()	1422	// Trace.debug("\n\t\t\tTrace: " + trace.getName()
Lines 1424-1431 Link Here
1424	// Clean up to empty line to draw on top	1430	// Clean up to empty line to draw on top
1425	int xEnd = rect.x + rect.width;	1431	int xEnd = rect.x + rect.width;
1426	fillSpace(rect, gc, selected, _rect1.x, xEnd, xEnd);	1432	fillSpace(rect, gc, selected, _rect1.x, xEnd, xEnd);
1427	if (count > 0) {	1433	if (iterator.hasNext()) {
1428	ITimeEvent currEvent = list.get(0);	1434	ITimeEvent currEvent = iterator.next();
1429	ITimeEvent nextEvent = null;	1435	ITimeEvent nextEvent = null;
1430	long currEventTime = currEvent.getTime();	1436	long currEventTime = currEvent.getTime();
1431	long currEventDuration = currEvent.getDuration();	1437	long currEventDuration = currEvent.getDuration();
Lines 1445-1452 Link Here
1445	// refresh current event duration as the loop moves	1451	// refresh current event duration as the loop moves
1446	currEventDuration = currEvent.getDuration();	1452	currEventDuration = currEvent.getDuration();
1447	// TsfTmTraceDeadEvent;	1453	// TsfTmTraceDeadEvent;
1448	if (idx < count) {	1454	if (iterator.hasNext()) {
1449	nextEvent = list.get(idx);	1455	nextEvent = iterator.next();
1450	nextEventTime = nextEvent.getTime();	1456	nextEventTime = nextEvent.getTime();
1451	idx++;	1457	idx++;
1452	} else if (stopped) {	1458	} else if (stopped) {
Lines 1485-1494 Link Here
1485	if (x1 >= rect.x && x0 <= xEnd) {	1491	if (x1 >= rect.x && x0 <= xEnd) {
1486	if (currEventDuration != 0) {	1492	if (currEventDuration != 0) {
1487	x0 = (double) (x0 >= rect.x ? x0 : rect.x);	1493	x0 = (double) (x0 >= rect.x ? x0 : rect.x);
1488	_rect1.width = (int) ((x1 <= xEnd ? x1 : xEnd) - x0);	1494	_rect1.width = (int) Math.ceil(x1 <= xEnd ? x1 : xEnd) - (int) x0;
1489	} else {	1495	} else {
1490	_rect1.width = 2; // make punctual events 2 pixels wide	1496	_rect1.width = 1; // make punctual events 2 pixels wide
1491	}	1497	}
		1498	_rect1.width = Math.max(_minimumItemWidth, _rect1.width);
1492	_rect1.x = (int) x0;	1499	_rect1.x = (int) x0;
1493	boolean timeSelected = currEventTime <= selectedTime	1500	boolean timeSelected = currEventTime <= selectedTime
1494	&& selectedTime < nextEventTime;	1501	&& selectedTime < nextEventTime;
Lines 1638-1654 Link Here
1638	public void focusGained(FocusEvent e) {	1645	public void focusGained(FocusEvent e) {
1639	_isInFocus = true;	1646	_isInFocus = true;
1640	redraw();	1647	redraw();
1641	getDisplay().addFilter(SWT.MouseWheel, mouseScrollFilterListener);	1648	if (mouseScrollFilterListener == null) {
		1649	mouseScrollFilterListener = new Listener() {
		1650	// This filter is used to prevent scrolling of the view when the
		1651	// mouse wheel is used to zoom
		1652	public void handleEvent(Event event) {
		1653	event.doit = false;
		1654	}
		1655	};
		1656	getDisplay().addFilter(SWT.MouseWheel, mouseScrollFilterListener);
		1657	}
1642	}	1658	}
1643		1659
1644	public void focusLost(FocusEvent e) {	1660	public void focusLost(FocusEvent e) {
1645	_isInFocus = false;	1661	_isInFocus = false;
1646	if (0 != _dragState) {	1662	if (DRAG_NONE != _dragState) {
1647	setCapture(false);	1663	setCapture(false);
1648	_dragState = 0;	1664	_dragState = DRAG_NONE;
1649	}	1665	}
1650	redraw();	1666	redraw();
1651	getDisplay().removeFilter(SWT.MouseWheel, mouseScrollFilterListener);	1667	if (mouseScrollFilterListener != null) {
		1668	getDisplay().removeFilter(SWT.MouseWheel, mouseScrollFilterListener);
		1669	mouseScrollFilterListener = null;
		1670	}
1652	}	1671	}
1653		1672
1654	public boolean isInFocus() {	1673	public boolean isInFocus() {
Lines 1659-1665 Link Here
1659	if (null == _timeProvider)	1678	if (null == _timeProvider)
1660	return;	1679	return;
1661	Point size = getCtrlSize();	1680	Point size = getCtrlSize();
1662	if (1 == _dragState) {	1681	if (DRAG_TRACE_ITEM == _dragState) {
1663	int nameWidth = _timeProvider.getNameSpace();	1682	int nameWidth = _timeProvider.getNameSpace();
1664	int x = e.x - nameWidth;	1683	int x = e.x - nameWidth;
1665	if (x > 0 && size.x > nameWidth && _dragX != x) {	1684	if (x > 0 && size.x > nameWidth && _dragX != x) {
Lines 1678-1687 Link Here
1678	}	1697	}
1679	_timeProvider.setStartFinishTime(time0, time1);	1698	_timeProvider.setStartFinishTime(time0, time1);
1680	}	1699	}
1681	} else if (3 == _dragState) {	1700	} else if (DRAG_SPLIT_LINE == _dragState) {
1682	_dragX = e.x;	1701	_dragX = e.x;
1683	_timeProvider.setNameSpace(_hitIdx + _dragX - _dragX0);	1702	_timeProvider.setNameSpace(_hitIdx + _dragX - _dragX0);
1684	} else if (0 == _dragState) {	1703	} else if (DRAG_NONE == _dragState) {
1685	boolean mouseHover = hitSplitTest(e.x, e.y) > 0;	1704	boolean mouseHover = hitSplitTest(e.x, e.y) > 0;
1686	if (_mouseHover != mouseHover)	1705	if (_mouseHover != mouseHover)
1687	redraw();	1706	redraw();
Lines 1769-1775 Link Here
1769	if (namewidth != 0) {	1788	if (namewidth != 0) {
1770	idx = hitSplitTest(e.x, e.y);	1789	idx = hitSplitTest(e.x, e.y);
1771	if (idx > 0) {	1790	if (idx > 0) {
1772	_dragState = 3;	1791	_dragState = DRAG_SPLIT_LINE;
1773	_dragX = _dragX0 = e.x;	1792	_dragX = _dragX0 = e.x;
1774	_hitIdx = _timeProvider.getNameSpace();	1793	_hitIdx = _timeProvider.getNameSpace();
1775	;	1794	;
Lines 1783-1822 Link Here
1783	idx = hitTest(e.x, e.y);	1802	idx = hitTest(e.x, e.y);
1784	if (idx >= 0) {	1803	if (idx >= 0) {
1785	if (_data._items[idx] instanceof TraceItem) {	1804	if (_data._items[idx] instanceof TraceItem) {
1786	long hitTime = hitTimeTest(e.x, e.y);	1805	long hitTime = hitTimeTest(e.x);
1787	if (hitTime >= 0) {	1806	if (hitTime >= 0) {
1788	_timeProvider.setSelectedTimeInt(hitTime, false);	1807	// _timeProvider.setSelectedTimeInt(hitTime, false);
1789	setCapture(true);	1808	setCapture(true);
1790	_dragState = 1;	1809	_dragState = DRAG_TRACE_ITEM;
1791	_dragX = _dragX0 = e.x - _timeProvider.getNameSpace();	1810	_dragX = _dragX0 = e.x - _timeProvider.getNameSpace();
		1811	_hitIdx = idx;
1792	_time0bak = _timeProvider.getTime0();	1812	_time0bak = _timeProvider.getTime0();
1793	_time1bak = _timeProvider.getTime1();	1813	_time1bak = _timeProvider.getTime1();
		1814	return;
1794	}	1815	}
1795	} else if (_data._items[idx] instanceof GroupItem) {	1816	} else if (_data._items[idx] instanceof GroupItem) {
1796	_hitIdx = idx;	1817	_dragX0 = e.x;
1797	_dragState = 2;	1818	_dragState = DRAG_GROUP_ITEM;
1798	}	1819	}
1799	selectItem(idx, false);	1820	selectItem(idx, false);
1800	fireSelectionChanged();	1821	fireSelectionChanged();
1801	} else {	1822	} else {
1802	selectItem(idx, false); // clear selection	1823	selectItem(idx, false); // clear selection
		1824	redraw();
1803	}	1825	}
1804	}	1826	}
1805	}	1827	}
1806		1828
1807	public void mouseUp(MouseEvent e) {	1829	public void mouseUp(MouseEvent e) {
1808	if (0 != _dragState) {	1830	if (DRAG_NONE != _dragState) {
1809	setCapture(false);	1831	setCapture(false);
1810	if (1 == _dragState) {	1832	if (DRAG_TRACE_ITEM == _dragState) {
1811	// Notify time provider to check the need for listener notification	1833	// Notify time provider to check the need for listener notification
1812	_timeProvider.notifyStartFinishTime();	1834	_timeProvider.notifyStartFinishTime();
1813	} else if (2 == _dragState) {	1835	if (_dragX == _dragX0) { // click without drag
1814	if (hitTest(e.x, e.y) == _hitIdx)	1836	long time = hitTimeTest(e.x);
		1837	_timeProvider.setSelectedTimeInt(time, false);
		1838	selectItem(_hitIdx, false);
		1839	fireSelectionChanged();
		1840	}
		1841	} else if (DRAG_GROUP_ITEM == _dragState) {
		1842	if (e.x == _dragX0) // click without drag
1815	toggle(_hitIdx);	1843	toggle(_hitIdx);
1816	} else if (3 == _dragState) {	1844	} else if (DRAG_SPLIT_LINE == _dragState) {
1817	redraw();	1845	redraw();
1818	}	1846	}
1819	_dragState = 0;	1847	_dragState = DRAG_NONE;
1820	}	1848	}
1821	}	1849	}
1822		1850
Lines 1874-1880 Link Here
1874	}	1902	}
1875		1903
1876	public void mouseScrolled(MouseEvent e) {	1904	public void mouseScrolled(MouseEvent e) {
1877	if (!_isInFocus)	1905	if (!_isInFocus \|\| _dragState != DRAG_NONE)
1878	return;	1906	return;
1879	if (e.count > 0) {	1907	if (e.count > 0) {
1880	zoom(true);	1908	zoom(true);
Lines 1920-1925 Link Here
1920	this._itemHeight = rowHeight;	1948	this._itemHeight = rowHeight;
1921	}	1949	}
1922		1950
		1951	public void setMinimumItemWidth(int width) {
		1952	this._minimumItemWidth = width;
		1953	}
		1954
1923	public Vector<ITmfTimeAnalysisEntry> getFilteredOut() {	1955	public Vector<ITmfTimeAnalysisEntry> getFilteredOut() {
1924	return _data.getFilteredOut();	1956	return _data.getFilteredOut();
1925	}	1957	}
Lines 2056-2076 Link Here
2056	if (trace == null)	2088	if (trace == null)
2057	return null;	2089	return null;
2058		2090
2059	int traceId = trace.getId();
2060
2061	Integer idx = null;
2062	for (int i = 0; i < _items.length; i++) {	2091	for (int i = 0; i < _items.length; i++) {
2063	idx = i;
2064	Object item = _items[i];	2092	Object item = _items[i];
2065	if (item instanceof TraceItem) {	2093	if (item instanceof TraceItem) {
2066	TraceItem ti = (TraceItem) item;	2094	TraceItem ti = (TraceItem) item;
2067	if (ti._trace.getId() == traceId) {	2095	if (ti._trace == trace) {
2068	break;	2096	return i;
2069	}	2097	}
2070	}	2098	}
2071	}	2099	}
2072		2100
2073	return idx;	2101	return null;
2074	}	2102	}
2075		2103
2076	public void updateItems() {	2104	public void updateItems() {
Lines 2164-2169 Link Here
2164	// item = findTraceItem(parent);	2192	// item = findTraceItem(parent);
2165	// }	2193	// }
2166		2194
		2195	/*
		2196	* Check if this is still needed!
2167	ITmfTimeAnalysisEntry localTraceItem = item._trace;	2197	ITmfTimeAnalysisEntry localTraceItem = item._trace;
2168	// Local trace found	2198	// Local trace found
2169	Vector<TimeEvent> children = localTraceItem.getTraceEvents();	2199	Vector<TimeEvent> children = localTraceItem.getTraceEvents();
Lines 2179-2184 Link Here
2179	}	2209	}
2180	// Add the new item	2210	// Add the new item
2181	children.add(childItem);	2211	children.add(childItem);
		2212	*/
2182		2213
2183	}	2214	}
2184		2215

Lines 104-109 Link Here

(-)src/org/eclipse/linuxtools/tmf/ui/viewers/timeAnalysis/widgets/TimeScaleCtrl.java (+3 lines)
104	unit = MIN_IN_NS;	104	unit = MIN_IN_NS;
105	} else if (minDelta > 20 * SEC_IN_NS) {	105	} else if (minDelta > 20 * SEC_IN_NS) {
106	unit = 30 * SEC_IN_NS;	106	unit = 30 * SEC_IN_NS;
		107	} else if (minDelta <= 1) {
		108	_timeDelta = 1;
		109	return;
107	}	110	}
108	}	111	}
109	double log = Math.log10((double) minDelta / unit);	112	double log = Math.log10((double) minDelta / unit);




import java.text.SimpleDateFormat;
import java.util.Date;
import java.util.Iterator;
import java.util.List;
import java.util.TimeZone;
import java.util.Vector;

import org.eclipse.linuxtools.tmf.ui.viewers.timeAnalysis.ITimeAnalysisViewer.TimeFormat;
import org.eclipse.linuxtools.tmf.ui.viewers.timeAnalysis.model.ITimeEvent;
import org.eclipse.linuxtools.tmf.ui.viewers.timeAnalysis.model.ITmfTimeAnalysisEntry;
import org.eclipse.linuxtools.tmf.ui.viewers.timeAnalysis.model.TimeEvent;
import org.eclipse.swt.graphics.Color;
import org.eclipse.swt.graphics.Device;
import org.eclipse.swt.graphics.GC;

	static ITimeEvent getFirstEvent(ITmfTimeAnalysisEntry thread) {
		if (null == thread)
			return null;
		Iterator<ITimeEvent> iterator = thread.getTraceEventsIterator();
		if (iterator.hasNext()) {
		    return iterator.next();
		} else {
		    return null;
		}
	}

	/**

    static ITimeEvent findEvent(ITmfTimeAnalysisEntry thread, long time, int n) {
        if (null == thread)
            return null;
        Iterator<ITimeEvent> iterator = thread.getTraceEventsIterator();
        Iterator<TimeEvent> it = list.iterator();
        ITimeEvent nextEvent = null;
        ITimeEvent currEvent = null;
        ITimeEvent prevEvent = null;

        while (iterator.hasNext()) {
            nextEvent = (ITimeEvent) iterator.next();
            long nextStartTime = nextEvent.getTime();
            
            if (nextStartTime > time) {




					Item item) {
				if (item instanceof TraceItem) {
					ITmfTimeAnalysisEntry thrd = ((TraceItem) item)._trace;
					ITimeEvent threadEvent = Utils.findEvent(thrd, threadStates.hitTimeTest(pt.x), 2);
					ITimeEvent nextEvent = Utils.findEvent(thrd, threadStates.hitTimeTest(pt.x), 1);
					ITimeEvent nextEvent = Utils.findEvent(thrd, threadStates
							.hitTimeTest(pt.x, pt.y), 1);
					// thread name
					addItem(Messages._TRACE_NAME, thrd.getName());
					// class name
					String traceClass = _utilImp.getTraceClassName(thrd);
					if (traceClass != null) {
					    addItem(Messages._TRACE_CLASS_NAME, traceClass);
					}
					// thread state
					String state = _utilImp.getEventName(threadEvent);
					if (state != null) {
					    addItem(Messages._TRACE_STATE, state);
					}

					// This block receives a
					// list of <String, String> values to be added to the tip
					// table
					Map<String, String> eventAddOns = _utilImp.getEventHoverToolTipInfo(threadEvent);
					if (eventAddOns != null) {
					    for (Iterator<String> iter = eventAddOns.keySet().iterator(); iter.hasNext();) {
					        String message = (String) iter.next();
					        addItem(message, eventAddOns.get(message));
					    }
					}

					long eventStartTime = -1;




package org.eclipse.linuxtools.tmf.ui.views.timechart;

import java.util.Iterator;
import java.util.NoSuchElementException;
import java.util.Vector;

import org.eclipse.linuxtools.tmf.trace.ITmfTrace;
import org.eclipse.linuxtools.tmf.ui.viewers.timeAnalysis.model.ITimeEvent;
import org.eclipse.linuxtools.tmf.ui.viewers.timeAnalysis.model.ITmfTimeAnalysisEntry;

public class TimeChartAnalysisEntry implements ITmfTimeAnalysisEntry {

    private ITmfTrace fTrace;
    private String fGroup;
    private Vector<TimeChartEvent> fTraceEvents;
    private int fPower = 0; // 2^fPower nanoseconds per vector position
    private long fReferenceTime = -1; // time corresponding to beginning of index 0
    private long fStartTime = -1; // time of first event
    private long fStopTime = -1; // time of last event
    private long fLastRank = -1; // rank of last processed trace event

    TimeChartAnalysisEntry(ITmfTrace trace, int modelSize) {
        fTrace = trace;
        fTraceEvents = new Vector<TimeChartEvent>(modelSize);
    }
    
    TimeChartAnalysisEntry(ITmfTrace trace, String group, int modelSize) {
        fTrace = trace;
        fTraceEvents = new Vector<TimeChartEvent>(modelSize);
        fGroup = group;
    }
    
    public String getGroupName() {
        return fGroup;
    }

    public int getId() {
        // TODO Auto-generated method stub
        return 0;
    }

    public String getName() {
        return fTrace.getName();
    }

    public long getStartTime() {
        return fStartTime;
    }

    public long getStopTime() {
        return fStopTime;
    }

    @Deprecated public <T extends ITimeEvent> Vector<T> getTraceEvents() {
        return null;
    }

    public Iterator<ITimeEvent> getTraceEventsIterator() {
        return new EntryIterator(0, Long.MAX_VALUE, 0);
    }
    
    public Iterator<ITimeEvent> getTraceEventsIterator(long startTime, long stopTime, long maxDuration) {
        return new EntryIterator(startTime, stopTime, maxDuration);
    }
    
    private class EntryIterator implements Iterator<ITimeEvent> {
        private final long fIteratorStartTime;
        private final long fIteratorStopTime;
        private final long fIteratorMaxDuration;
        private long lastTime = -1;
        private TimeChartEvent next = null;
        private Iterator<ITimeEvent> nestedIterator = null;
        
        public EntryIterator(long startTime, long stopTime, long maxDuration) {
            fIteratorStartTime = startTime;
            fIteratorStopTime = stopTime;
            fIteratorMaxDuration = maxDuration;
        }
        
        public boolean hasNext() {
            synchronized (fTraceEvents) {
                if (next != null) return true;
                if (nestedIterator != null) {
                    if (nestedIterator.hasNext()) {
                        return true;
                    } else {
                        nestedIterator = null;
                    }
                }
                long time = (lastTime == -1) ? fStartTime : lastTime;
                int index = (fReferenceTime == -1) ? 0 : (int) ((time - fReferenceTime) >> fPower);
                while (index < fTraceEvents.size()) {
                    TimeChartEvent event = fTraceEvents.get(index++);
                    if (event != null && (lastTime == -1 || event.getTime() > time)) {
                        if (event.getTime() + event.getDuration() >= fIteratorStartTime && event.getTime() <= fIteratorStopTime) {
                            if (event.getItemizedEntry() == null || event.getDuration() <= fIteratorMaxDuration) {
                                lastTime = event.getTime() + event.getDuration();
                                next = event;
                                return true;
                            } else {
                                nestedIterator = event.getItemizedEntry().getTraceEventsIterator(fIteratorStartTime, fIteratorStopTime, fIteratorMaxDuration);
                                return nestedIterator.hasNext();
                            }
                        }
                    }
                }
                return false;
            }
        }

        public TimeChartEvent next() {
            synchronized (fTraceEvents) {
                if (nestedIterator != null) {
                    TimeChartEvent event = (TimeChartEvent) nestedIterator.next();
                    lastTime = event.getTime() + event.getDuration();
                    return event;  
                }
                if (hasNext()) {
                    TimeChartEvent event = next;
                    next = null;
                    return event;
                }
                throw new NoSuchElementException();
            }
        }

        public void remove() {
            throw new UnsupportedOperationException();
        }
            
    }

    public void addTraceEvent(ITimeEvent timeEvent) {
        long time = timeEvent.getTime();
        synchronized (fTraceEvents) {
            long index = (fReferenceTime == -1) ? 0 : (time - fReferenceTime) >> fPower;
            if (index < 0) {
                if (fTraceEvents.capacity() - fTraceEvents.size() < -index) {
                    int powershift = (-index + fTraceEvents.size() <= 2 * fTraceEvents.capacity()) ? 1 :
                        (int) Math.ceil(Math.log((double) (-index + fTraceEvents.size()) / fTraceEvents.capacity()) / Math.log(2));
                    merge(powershift);
                    index = index >> powershift;
                }
                shift((int) -index);
                index = 0;
                fTraceEvents.set(0, (TimeChartEvent) timeEvent);
            } else if (index < fTraceEvents.capacity()) {
                if (index >= fTraceEvents.size()) {
                    fTraceEvents.setSize((int) index + 1);
                }
            } else {
                int powershift = (index < 2 * fTraceEvents.capacity()) ? 1 :
                    (int) Math.ceil(Math.log((double) (index + 1) / fTraceEvents.capacity()) / Math.log(2));
                merge(powershift);
                fTraceEvents.setSize((int) (index >> powershift) + 1);
                index = (int) (index >> powershift);
            }
            TimeChartEvent event = (TimeChartEvent) fTraceEvents.get((int) index);
            if (event == null) {
                fTraceEvents.set((int) index, (TimeChartEvent) timeEvent);
            } else {
                if (event.getItemizedEntry() == null) {
                    event.merge((TimeChartEvent) timeEvent);
                } else {
                    event.getItemizedEntry().addTraceEvent(timeEvent);
                }
            }
        }
        if (fReferenceTime == -1 || time < fReferenceTime) {
            fReferenceTime = (time >> fPower) << fPower;
        }
        if (fStartTime == -1 || time < fStartTime) {
            fStartTime = time;
        }
        if (fStopTime == -1 || time > fStopTime) {
            fStopTime = time;
        }
    }

    private void merge(int powershift) {
        fPower += powershift;
        fReferenceTime = (fReferenceTime >> fPower) << fPower;
        int index = 0;
        for (int i = 0; i < fTraceEvents.size(); i++) {
            TimeChartEvent event = fTraceEvents.get(i);
            if (event != null) {
                index = (int) ((event.getTime() - fReferenceTime) >> fPower);
                TimeChartEvent mergedEvent = (TimeChartEvent) fTraceEvents.get(index);
                if (mergedEvent == null) {
                    fTraceEvents.set(index, event);
                } else {
                    mergedEvent.merge(event);
                }
                if (i != index) {
                    fTraceEvents.set(i, null);
                }
            }
        }
        fTraceEvents.setSize(index + 1);
    }

    private void shift(int indexshift) {
        int oldSize = fTraceEvents.size();
        fTraceEvents.setSize(oldSize + indexshift);
        for (int i = oldSize - 1; i >= 0; i--) {
            fTraceEvents.set(i + indexshift, fTraceEvents.get(i));
        }
        for (int i = 0; i < indexshift; i++) {
            fTraceEvents.set(i, null);
        }
    }
    
    public ITmfTrace getTrace() {
        return fTrace;
    }
    
    public void setLastRank(long rank) {
        fLastRank = rank;
    }
    
    public long getLastRank() {
        return fLastRank;
    }
}




package org.eclipse.linuxtools.tmf.ui.views.timechart;

import java.util.Map;

import org.eclipse.linuxtools.tmf.ui.viewers.timeAnalysis.TmfTimeAnalysisProvider;
import org.eclipse.linuxtools.tmf.ui.viewers.timeAnalysis.model.ITimeEvent;
import org.eclipse.linuxtools.tmf.ui.viewers.timeAnalysis.model.ITmfTimeAnalysisEntry;

public class TimeChartAnalysisProvider extends TmfTimeAnalysisProvider {

    @Override
    public StateColor getEventColor(ITimeEvent event) {
        return StateColor.MAGENTA3;
    }

    @Override
    public String getTraceClassName(ITmfTimeAnalysisEntry entry) {
        return null;
    }

    @Override
    public String getEventName(ITimeEvent event, boolean upper, boolean extInfo) {
        return null;
    }

    @Override
    public Map<String, String> getEventHoverToolTipInfo(ITimeEvent event) {
        return null;
    }

    @Override
    public String getStateName(StateColor color) {
        return null;
    }

}




package org.eclipse.linuxtools.tmf.ui.views.timechart;

import java.util.ArrayList;
import java.util.Iterator;

import org.eclipse.linuxtools.tmf.event.TmfEvent;
import org.eclipse.linuxtools.tmf.ui.viewers.timeAnalysis.model.ITimeEvent;
import org.eclipse.linuxtools.tmf.ui.viewers.timeAnalysis.model.ITmfTimeAnalysisEntry;

public class TimeChartEvent implements ITimeEvent {

    private static final byte TIMESTAMP_SCALE = -9;
    
    private TimeChartAnalysisEntry fParentEntry;
    private long fTime;
    private long fDuration;
    private long fFirstRank;
    private long fLastRank;
    private RankRangeList fRankRangeList;
    private long fNbEvents;
    private TimeChartAnalysisEntry fItemizedEntry;
    private boolean fItemizing;

    public TimeChartEvent(TimeChartAnalysisEntry parentEntry, TmfEvent event, long rank) {
        fParentEntry = parentEntry;
        fTime = event.getTimestamp().synchronize((long) 0, TIMESTAMP_SCALE).getValue();
        fDuration = 0;
        fFirstRank = fLastRank = rank;
        fRankRangeList = new RankRangeList(rank);
        fNbEvents = 1;
    }

    public ITmfTimeAnalysisEntry getEntry() {
        return fParentEntry;
    }

    public long getTime() {
        return fTime;
    }

    public long getDuration() {
        return fDuration;
    }

    public long getFirstRank() {
        return fFirstRank;
    }
    
    public long getLastRank() {
        return fLastRank;
    }
    
    public RankRangeList getRankRangeList() {
        return fRankRangeList;
    }
    
    public void merge(TimeChartEvent event) {
        if (fTime == event.getTime() && fDuration == event.getDuration()) return;
        long endTime = Math.max(fTime + fDuration, event.getTime() + event.getDuration());
        fTime = Math.min(fTime, event.getTime());
        fDuration = endTime - fTime;
        fFirstRank = Math.min(fFirstRank, event.fFirstRank);
        fLastRank = Math.max(fLastRank, event.fLastRank);
        fNbEvents += event.fNbEvents;
        fItemizedEntry = null;
        fRankRangeList.merge(event.getRankRangeList());
    }

    public long getNbEvents() {
        return fNbEvents;
    }

    public void setItemizedEntry(TimeChartAnalysisEntry timeAnalysisEntry) {
        fItemizedEntry = timeAnalysisEntry;
    }

    public TimeChartAnalysisEntry getItemizedEntry() {
        return fItemizedEntry;
    }

    public boolean isItemizing() {
        return fItemizing;
    }

    public void setItemizing(boolean itemizing) {
        fItemizing = itemizing;
    }

    public class RankRange {
        private long firstRank;
        private long lastRank;
        
        public RankRange(long firstRank, long lastRank) {
            this.firstRank = firstRank;
            this.lastRank = lastRank;
        }

        public long getFirstRank() {
            return firstRank;
        }

        public long getLastRank() {
            return lastRank;
        }

        public long distanceFrom(RankRange range) {
            if (range.lastRank < fFirstRank) {
                return fFirstRank - range.lastRank;
            } else if (range.firstRank > fLastRank) {
                return range.firstRank - fLastRank;
            } else {
                return 0;
            }
        }
        
        public String toString() {
            return "["+firstRank+","+lastRank+"]";
        }
    }
    
    private class RankRangeList extends ArrayList<RankRange> {
        
        private static final long serialVersionUID = 6060485531208535986L;

        public RankRangeList(long rank) {
            super(1);
            add(new RankRange(rank, rank));
        }
        
        public void merge(RankRangeList rankRangeList) {
            long threshold = fParentEntry.getTrace().getCacheSize();
            for (RankRange newRange : rankRangeList) {
                boolean merged = false;
                for (RankRange oldRange : fRankRangeList) {
                    if (newRange.distanceFrom(oldRange) <= threshold) {
                        oldRange.firstRank = Math.min(oldRange.firstRank, newRange.firstRank);
                        oldRange.lastRank = Math.max(oldRange.lastRank, newRange.lastRank);
                        merged = true;
                        break;
                    }
                }
                if (!merged) {
                    add(newRange);
                }
            }
            Iterator<RankRange> iterator = fRankRangeList.iterator();
            RankRange previous = null;
            while (iterator.hasNext()) {
                RankRange range = iterator.next();
                if (previous != null && range.distanceFrom(previous) <= threshold) {
                    previous.firstRank = Math.min(previous.firstRank, range.firstRank);
                    previous.lastRank = Math.max(previous.lastRank, range.lastRank);
                    iterator.remove();
                }
                previous = range;
            }
        }
    }
}




package org.eclipse.linuxtools.tmf.ui.views.timechart;

import java.util.Iterator;
import java.util.Vector;

import org.eclipse.core.runtime.IProgressMonitor;
import org.eclipse.core.runtime.IStatus;
import org.eclipse.core.runtime.Status;
import org.eclipse.core.runtime.jobs.Job;
import org.eclipse.linuxtools.tmf.event.TmfEvent;
import org.eclipse.linuxtools.tmf.event.TmfTimestamp;
import org.eclipse.linuxtools.tmf.signal.TmfSignalHandler;
import org.eclipse.linuxtools.tmf.signal.TmfTimeSynchSignal;
import org.eclipse.linuxtools.tmf.signal.TmfTraceClosedSignal;
import org.eclipse.linuxtools.tmf.signal.TmfTraceOpenedSignal;
import org.eclipse.linuxtools.tmf.signal.TmfTraceSelectedSignal;
import org.eclipse.linuxtools.tmf.signal.TmfTraceUpdatedSignal;
import org.eclipse.linuxtools.tmf.trace.ITmfTrace;
import org.eclipse.linuxtools.tmf.trace.TmfContext;
import org.eclipse.linuxtools.tmf.ui.editors.ITmfTraceEditor;
import org.eclipse.linuxtools.tmf.ui.viewers.TmfViewerFactory;
import org.eclipse.linuxtools.tmf.ui.viewers.timeAnalysis.ITimeAnalysisViewer;
import org.eclipse.linuxtools.tmf.ui.viewers.timeAnalysis.ITmfTimeScaleSelectionListener;
import org.eclipse.linuxtools.tmf.ui.viewers.timeAnalysis.ITmfTimeSelectionListener;
import org.eclipse.linuxtools.tmf.ui.viewers.timeAnalysis.TmfTimeScaleSelectionEvent;
import org.eclipse.linuxtools.tmf.ui.viewers.timeAnalysis.TmfTimeSelectionEvent;
import org.eclipse.linuxtools.tmf.ui.viewers.timeAnalysis.model.ITimeEvent;
import org.eclipse.linuxtools.tmf.ui.viewers.timeAnalysis.model.ITmfTimeAnalysisEntry;
import org.eclipse.linuxtools.tmf.ui.views.TmfView;
import org.eclipse.linuxtools.tmf.ui.views.timechart.TimeChartEvent.RankRange;
import org.eclipse.swt.SWT;
import org.eclipse.swt.layout.GridLayout;
import org.eclipse.swt.widgets.Composite;
import org.eclipse.swt.widgets.Display;
import org.eclipse.ui.IEditorPart;
import org.eclipse.ui.IEditorReference;


public class TimeChartView extends TmfView implements ITmfTimeScaleSelectionListener, ITmfTimeSelectionListener {

    public static final String ID = "org.eclipse.linuxtools.tmf.ui.views.timechart";

    private static final byte TIMESTAMP_SCALE = -9;
    
    private int fDisplayWidth;
    private Composite fComposite;
    private ITimeAnalysisViewer fViewer;
    private Vector<TimeChartAnalysisEntry> fTimeAnalysisEntries;

    public TimeChartView() {
        super("Time Chart");
        fDisplayWidth = Display.getDefault().getBounds().width;
    }

    @Override
    public void createPartControl(Composite parent) {
        fComposite = new Composite(parent, SWT.NONE);
        GridLayout gl = new GridLayout();
        gl.marginWidth = 0;
        gl.marginHeight = 0;
        fComposite.setLayout(gl);
        
        fViewer = TmfViewerFactory.createViewer(fComposite, new TimeChartAnalysisProvider());
        fViewer.groupTraces(false);
        fViewer.setTimeCalendarFormat(true);
        fViewer.setAcceptSelectionAPIcalls(true);
        fViewer.addWidgetTimeScaleSelectionListner(this);
        fViewer.addWidgetSelectionListner(this);
        fViewer.setMinimumItemWidth(1);
        
        fTimeAnalysisEntries = new Vector<TimeChartAnalysisEntry>();
        IEditorReference[] editorReferences = getSite().getPage().getEditorReferences();
        for (IEditorReference editorReference : editorReferences) {
            IEditorPart editor = editorReference.getEditor(false);
            if (editor instanceof ITmfTraceEditor) {
                ITmfTrace trace = ((ITmfTraceEditor) editor).getTrace();
                if (trace != null) {
                    TimeChartAnalysisEntry timeAnalysisEntry = new TimeChartAnalysisEntry(trace, fDisplayWidth * 2);
                    fTimeAnalysisEntries.add(timeAnalysisEntry);
                    Job job = new ProcessTraceJob(timeAnalysisEntry);
                    job.schedule();
                }
            }
        }
        fViewer.display(fTimeAnalysisEntries.toArray(new TimeChartAnalysisEntry[0]));
    }

    @Override
    public void setFocus() {
        super.setFocus();
        fViewer.setFocus();
    }
    
    private class ProcessTraceJob extends Job {

        private TimeChartAnalysisEntry fTimeAnalysisEntry;

        public ProcessTraceJob(TimeChartAnalysisEntry timeAnalysisEntry) {
            super("ProcessTraceJob:"+timeAnalysisEntry.getName());
            fTimeAnalysisEntry = timeAnalysisEntry;
            setSystem(true);
        }

        @Override
        protected IStatus run(IProgressMonitor monitor) {
            updateTraceEntry(fTimeAnalysisEntry, Long.MAX_VALUE, 0, Long.MAX_VALUE);
            return Status.OK_STATUS;
        }
    }
    
    private void updateTraceEntry(TimeChartAnalysisEntry timeAnalysisEntry, long stopRank, long startTime, long stopTime) {
        ITmfTrace trace = timeAnalysisEntry.getTrace();
        TmfContext context = null;
        TmfTimestamp lastTimestamp = null;
        boolean done = false;
        while (!done) {
            synchronized (timeAnalysisEntry) {
                if (timeAnalysisEntry.getLastRank() >= trace.getNbEvents()) {
                    done = true;
                    break;
                }
                if (context == null || context.getRank() != timeAnalysisEntry.getLastRank()) {
                    if (timeAnalysisEntry.getLastRank() != -1) {
                        context = trace.seekEvent(timeAnalysisEntry.getLastRank());
                    } else {
                        //context = trace.seekLocation(null);
                        context = trace.seekEvent(0);
                    }
                }
                while (true) {
                    long rank = context.getRank();
                    TmfEvent event = trace.getNextEvent(context);
                    if (event == null) {
                        done = true;
                        break;
                    }
                    if (!event.getTimestamp().equals(lastTimestamp)) {
                        TimeChartEvent timeEvent = new TimeChartEvent(timeAnalysisEntry, event, rank);
                        if (timeEvent.getTime() >= startTime && timeEvent.getTime() <= stopTime) {
                            timeAnalysisEntry.addTraceEvent(timeEvent);
                        }
                        lastTimestamp = event.getTimestamp();
                    }
                    if (context.getRank() == trace.getNbEvents() || context.getRank() == stopRank) {
                        done = true;
                        break;
                    }
                    if (context.getRank() % trace.getCacheSize() == 1) {
                        break;
                    }
                }
                //timeAnalysisEntry.setLastRank(Math.min(trace.getNbEvents(), stopRank));
                timeAnalysisEntry.setLastRank(context.getRank());
            }
            refreshViewer(false);
        }
    }

    private void refreshViewer(boolean resetTimeIntervals) {
        if (fComposite == null) {
            return;
        }
        final boolean reset = resetTimeIntervals;
        // Perform the refresh on the UI thread
        Display.getDefault().asyncExec(new Runnable() {
            public void run() {
                if (!fComposite.isDisposed()) {
                    fViewer.display(fTimeAnalysisEntries.toArray(new TimeChartAnalysisEntry[0]));
                    if (reset) {
                        fViewer.resetStartFinishTime();
                    }
                }
            }
        });
    }
    
    private void itemize(long startTime, long stopTime) {
        for (int i = 0; i < fTimeAnalysisEntries.size(); i++) {
            Job job = new ItemizeJob(fTimeAnalysisEntries.get(i), startTime, stopTime);
            job.schedule();
        }
    }
    
    private class ItemizeJob extends Job {

        private TimeChartAnalysisEntry fTimeAnalysisEntry;
        private long fStartTime;
        private long fStopTime;
        private long fMaxDuration;
        
        private ItemizeJob(TimeChartAnalysisEntry timeAnalysisEntry, long startTime, long stopTime) {
            super("ItemizeJob:"+timeAnalysisEntry.getName());
            fTimeAnalysisEntry = timeAnalysisEntry;
            fStartTime = startTime;
            fStopTime = stopTime;
            setSystem(true);
            fMaxDuration =  3 * (fStopTime - fStartTime) / fDisplayWidth;
        }
        
        @Override
        protected IStatus run(IProgressMonitor monitor) {
            itemizeTraceEntry(fTimeAnalysisEntry);
            return Status.OK_STATUS;
        }

        public void itemizeTraceEntry(TimeChartAnalysisEntry timeAnalysisEntry) {
            Iterator<ITimeEvent> iterator = timeAnalysisEntry.getTraceEventsIterator();
            TimeChartEvent event = null;
            boolean hasNext = true;
            while (hasNext) {
                synchronized (timeAnalysisEntry) {
                    while (hasNext = iterator.hasNext()) {
                        event = (TimeChartEvent) iterator.next();
                        if (event.getTime() + event.getDuration() > fStartTime &&
                                event.getTime() < fStopTime &&
                                event.getDuration() > fMaxDuration &&
                                event.getNbEvents() > 1) {
                            break;
                        }
                    }
                }
                if (hasNext) {
                    if (event.getItemizedEntry() == null) {
                        itemizeEvent((TimeChartEvent) event);
                    } else {
                        itemizeTraceEntry(event.getItemizedEntry());
                    }
                }
            }
        }

        public void itemizeEvent(TimeChartEvent event) {
            synchronized (event) {
                if (event.isItemizing()) {
                    return;
                }
                event.setItemizing(true);
            }
            TimeChartAnalysisEntry timeAnalysisEntry = new TimeChartAnalysisEntry(fTimeAnalysisEntry.getTrace(),
                    (int) Math.min(event.getNbEvents() + 1, fDisplayWidth * 2));
            for (RankRange range : event.getRankRangeList()) {
                timeAnalysisEntry.setLastRank(range.getFirstRank());
                updateTraceEntry(timeAnalysisEntry, range.getLastRank() + 1, event.getTime(), event.getTime() + event.getDuration());
            }
            event.setItemizedEntry(timeAnalysisEntry);
            refreshViewer(false);
            itemizeTraceEntry(timeAnalysisEntry);
            synchronized (event) {
                event.setItemizing(false);
            }
        }
    }

    // ------------------------------------------------------------------------
    // Listeners
    // ------------------------------------------------------------------------
    
    public void tsfTmProcessTimeScaleEvent(TmfTimeScaleSelectionEvent event) {
        itemize(event.getTime0(), event.getTime1());
    }

    public void tsfTmProcessSelEvent(TmfTimeSelectionEvent event) {
        ITmfTimeAnalysisEntry timeAnalysisEntry = null;
        if (event.getSelection() instanceof TimeChartAnalysisEntry) {
            timeAnalysisEntry = (TimeChartAnalysisEntry) event.getSelection();
        } else if (event.getSelection() instanceof TimeChartEvent) {
            timeAnalysisEntry = ((TimeChartEvent) event.getSelection()).getEntry();
        }
        if (timeAnalysisEntry instanceof TimeChartAnalysisEntry) {
            broadcast(new TmfTraceSelectedSignal(this, ((TimeChartAnalysisEntry) timeAnalysisEntry).getTrace()));
        }
        broadcast(new TmfTimeSynchSignal(this, new TmfTimestamp(event.getSelectedTime(), TIMESTAMP_SCALE)));
    }

    // ------------------------------------------------------------------------
    // Signal handlers
    // ------------------------------------------------------------------------
    
    @TmfSignalHandler
    public void traceOpened(TmfTraceOpenedSignal signal) {
        if (fTimeAnalysisEntries == null) return;
        final ITmfTrace trace = signal.getTrace();
        TimeChartAnalysisEntry timeAnalysisEntry = null;
        for (int i = 0; i < fTimeAnalysisEntries.size(); i++) {
            if (fTimeAnalysisEntries.get(i).getTrace().equals(trace)) {
                timeAnalysisEntry = fTimeAnalysisEntries.get(i);
                break;
            }
        }
        if (timeAnalysisEntry == null) {
            timeAnalysisEntry = new TimeChartAnalysisEntry(trace, fDisplayWidth * 2); 
            fTimeAnalysisEntries.add(timeAnalysisEntry);
            Job job = new ProcessTraceJob(timeAnalysisEntry);
            job.schedule();
        }
        refreshViewer(true);
    }
    
    @TmfSignalHandler
    public void traceClosed(TmfTraceClosedSignal signal) {
        if (fTimeAnalysisEntries == null) return;
        final ITmfTrace trace = signal.getTrace();
        for (int i = 0; i < fTimeAnalysisEntries.size(); i++) {
            if (fTimeAnalysisEntries.get(i).getTrace().equals(trace)) {
                fTimeAnalysisEntries.remove(i);
                refreshViewer(true);
                break;
            }
        }
    }
    
    @TmfSignalHandler
    public void traceSelected(TmfTraceSelectedSignal signal) {
        if (signal.getSource() != this && fTimeAnalysisEntries != null) {
            ITmfTrace trace = signal.getTrace();
            for (int i = 0; i < fTimeAnalysisEntries.size(); i++) {
                if (fTimeAnalysisEntries.get(i).getTrace().equals(trace)) {
                    fViewer.setSelectedTrace(fTimeAnalysisEntries.get(i));
                    break;
                }
            }
        }
    }

    @TmfSignalHandler
    public void traceUpdated(TmfTraceUpdatedSignal signal) {
        if (fTimeAnalysisEntries == null) return;
        final ITmfTrace trace = signal.getTrace();
        for (int i = 0; i < fTimeAnalysisEntries.size(); i++) {
            TimeChartAnalysisEntry timeAnalysisEntry = fTimeAnalysisEntries.get(i);
            if (timeAnalysisEntry.getTrace().equals(trace)) {
                updateTraceEntry(timeAnalysisEntry, Long.MAX_VALUE, 0, Long.MAX_VALUE);
                break;
            }
        }
    }

    @TmfSignalHandler
    public void currentTimeUpdated(TmfTimeSynchSignal signal) {
        long time = signal.getCurrentTime().synchronize(0, TIMESTAMP_SCALE).getValue();
        fViewer.setSelectedTime(time, true, this);
    }
    
}

Lines 26-31 Link Here

(-)plugin.xml (+7 lines)
26	name="Events"	26	name="Events"
27	restorable="true">	27	restorable="true">
28	</view>	28	</view>
		29	<view
		30	category="org.eclipse.linuxtools.tmf.ui.views.category"
		31	class="org.eclipse.linuxtools.tmf.ui.views.timechart.TimeChartView"
		32	id="org.eclipse.linuxtools.tmf.ui.views.timechart"
		33	name="Time Chart"
		34	restorable="true">
		35	</view>
29	</extension>	36	</extension>
30	<extension	37	<extension
31	point="org.eclipse.ui.editors">	38	point="org.eclipse.ui.editors">

Lines 83-89 Link Here

(-)widgetStubs/org/eclipse/linuxtools/tmf/ui/widgets/timeAnalysis/test/stub/model/TraceModelImplFactory.java (-2 / +2 lines)
83		83
84	event = new EventImpl(eventTime, trace, getEventType(i%16));	84	event = new EventImpl(eventTime, trace, getEventType(i%16));
85	event.setDuration(duration);	85	event.setDuration(duration);
86	trace.getTraceEvents().add(event);	86	trace.addTraceEvent(event);
87	}	87	}
88	}	88	}
89		89
Lines 98-104 Link Here
98	// duration = i + (long) ((i % 4));	98	// duration = i + (long) ((i % 4));
99	event = new EventImpl(eventTime, trace, getEventType(i));	99	event = new EventImpl(eventTime, trace, getEventType(i));
100	event.setDuration(duration);	100	event.setDuration(duration);
101	trace.getTraceEvents().add(event);	101	trace.addTraceEvent(event);
102	}	102	}
103	}	103	}
104		104




 *******************************************************************************/
package org.eclipse.linuxtools.tmf.ui.widgets.timeAnalysis.test.stub.model;

import java.util.Iterator;
import java.util.Vector;

import org.eclipse.linuxtools.tmf.ui.viewers.timeAnalysis.model.ITimeEvent;
import org.eclipse.linuxtools.tmf.ui.viewers.timeAnalysis.model.ITmfTimeAnalysisEntry;
import org.eclipse.linuxtools.tmf.ui.viewers.timeAnalysis.model.TimeEvent;


public class TraceImpl implements ITmfTimeAnalysisEntry {

	private long stopTime = 1;
	private String groupName = "defaultGroupName";
	private String className = "defaultClassName";
	private Vector<ITimeEvent> traceEvents = new Vector<ITimeEvent>();
	
	// ========================================================================
	// Constructor

		return stopTime;
	}

	@Deprecated public Vector<ITimeEvent> getTraceEvents() {
	    return traceEvents;
		return traceEvents;
	}
	
    public Iterator<ITimeEvent> getTraceEventsIterator() {
        return traceEvents.iterator();
    }

    public Iterator<ITimeEvent> getTraceEventsIterator(long startTime, long stopTime, long maxDuration) {
        return traceEvents.iterator();
    }

    public void addTraceEvent(ITimeEvent event) {
        traceEvents.add(event);
    }

}




import org.eclipse.jface.viewers.ViewerSorter;
import org.eclipse.linuxtools.tmf.ui.viewers.TmfViewerFactory;
import org.eclipse.linuxtools.tmf.ui.viewers.timeAnalysis.ITimeAnalysisViewer;
import org.eclipse.linuxtools.tmf.ui.viewers.timeAnalysis.ITmfTimeScaleSelectionListener;
import org.eclipse.linuxtools.tmf.ui.viewers.timeAnalysis.ITmfTimeSelectionListener;
import org.eclipse.linuxtools.tmf.ui.viewers.timeAnalysis.TmfTimeScaleSelectionEvent;
import org.eclipse.linuxtools.tmf.ui.viewers.timeAnalysis.TmfTimeSelectionEvent;
import org.eclipse.linuxtools.tmf.ui.viewers.timeAnalysis.ITmfTimeScaleSelectionListener;
import org.eclipse.linuxtools.tmf.ui.viewers.timeAnalysis.model.ITmfTimeAnalysisEntry;
import org.eclipse.linuxtools.tmf.ui.widgets.timeAnalysis.test.stub.adaption.TsfImplProvider;
import org.eclipse.linuxtools.tmf.ui.widgets.timeAnalysis.test.stub.model.EventImpl;

							+ selTrace.getName().toString()
							+ "\nClass Name: "
							+ selTrace.getClassName()
							+ "\nNumber of Events: "
							+ selTrace.getTraceEvents().size()
							+ "\nSelection Type: "
							+ event.getDType().toString()
							+ "\nSelected Time: "

Return to bug 325016

Lines 14-30 Link Here

(-)src/org/eclipse/linuxtools/tmf/ui/viewers/timeAnalysis/model/TimeEvent.java (-3 / +3 lines)
14		14
15	public abstract class TimeEvent implements ITimeEvent {	15	public abstract class TimeEvent implements ITimeEvent {
16	/* (non-Javadoc)	16	/* (non-Javadoc)
17	* @see org.eclipse.linuxtools.tlf.widgets.timeAnalysis.model.TmTaEventI#getTrace()	17	* @see org.eclipse.linuxtools.tmf.ui.viewers.timeAnalysis.model.ITimeEvent#getTrace()
18	*/	18	*/
19	public abstract ITmfTimeAnalysisEntry getEntry();	19	public abstract ITmfTimeAnalysisEntry getEntry();
20		20
21	/* (non-Javadoc)	21	/* (non-Javadoc)
22	* @see org.eclipse.linuxtools.tlf.widgets.timeAnalysis.model.TmTaEventI#getTime()	22	* @see org.eclipse.linuxtools.tmf.ui.viewers.timeAnalysis.model.ITimeEvent#getTime()
23	*/	23	*/
24	public abstract long getTime();	24	public abstract long getTime();
25		25
26	/* (non-Javadoc)	26	/* (non-Javadoc)
27	* @see org.eclipse.linuxtools.tlf.widgets.timeAnalysis.model.TmTaEventI#getDuration()	27	* @see org.eclipse.linuxtools.tmf.ui.viewers.timeAnalysis.model.ITimeEvent#getDuration()
28	*/	28	*/
29	public long getDuration() {	29	public long getDuration() {
30	return -1;	30	return -1;

Lines 12-17 Link Here

(-)src/org/eclipse/linuxtools/tmf/ui/viewers/timeAnalysis/model/ITmfTimeAnalysisEntry.java (-1 / +24 lines)
12		12
13	package org.eclipse.linuxtools.tmf.ui.viewers.timeAnalysis.model;	13	package org.eclipse.linuxtools.tmf.ui.viewers.timeAnalysis.model;
14		14
		15	import java.util.Iterator;
15	import java.util.Vector;	16	import java.util.Vector;
16		17
17	public interface ITmfTimeAnalysisEntry {	18	public interface ITmfTimeAnalysisEntry {
Lines 26-30 Link Here
26		27
27	public long getStopTime();	28	public long getStopTime();
28		29
29	public <T extends ITimeEvent> Vector<T> getTraceEvents();	30	/**
		31	* Get a vector containing all events
		32	* @deprecated replaced by {@link #getTraceEventsIterator()}
		33	*/
		34	@Deprecated public <T extends ITimeEvent> Vector<T> getTraceEvents();
		35
		36	/**
		37	* Get an iterator which returns all events
		38	*/
		39	public <T extends ITimeEvent> Iterator<T> getTraceEventsIterator();
		40
		41	/**
		42	* Get an iterator which only returns events that fall within the start time and the stop time.
		43	* The visible duration is the event duration below which further detail is not discernible.
		44	* If no such iterator is implemented, provide a basic iterator which returns all events.
		45	*
		46	* @param startTime start time in nanoseconds
		47	* @param stopTime stop time in nanoseconds
		48	* @param visibleDuration duration of one pixel in nanoseconds
		49	*/
		50	public <T extends ITimeEvent> Iterator<T> getTraceEventsIterator(long startTime, long stopTime, long visibleDuration);
		51
		52	public <T extends ITimeEvent> void addTraceEvent(T event);
30	}	53	}

Lines 14-22 Link Here

(-)src/org/eclipse/linuxtools/tmf/ui/viewers/timeAnalysis/messages.properties (-7 / +7 lines)
14	TRACE_STATES_TITLE = States Transition Visualizer	14	TRACE_STATES_TITLE = States Transition Visualizer
15		15
16	# labels	16	# labels
17	_TRACE_ID = Process Id	17	_TRACE_ID = Trace Id
18	_TRACE_DATE = Date	18	_TRACE_DATE = Date
19	_TRACE_NAME = Process Name	19	_TRACE_NAME = Trace Name
20	_TRACE_CLASS_NAME = Class Name	20	_TRACE_CLASS_NAME = Class Name
21	_TRACE_GROUP_NAME = Group Name	21	_TRACE_GROUP_NAME = Group Name
22	_TRACE_START_TIME = Start Time	22	_TRACE_START_TIME = Start Time
Lines 24-39 Link Here
24	_TRACE_STOP_TIME = Stop Time	24	_TRACE_STOP_TIME = Stop Time
25	_DURATION = Duration	25	_DURATION = Duration
26	_TRACE_STATE = State	26	_TRACE_STATE = State
27	_NUMBER_OF_TRACES = Number of processes	27	_NUMBER_OF_TRACES = Number of traces
28	_TRACE_FILTER = Process Filter	28	_TRACE_FILTER = Trace Filter
29	_TRACE_FILTER_DESC = Define the filter set	29	_TRACE_FILTER_DESC = Define the filter set
30	_Timescale = Time scale	30	_Timescale = Time scale
31	_UNDEFINED_GROUP = <undefined>	31	_UNDEFINED_GROUP = <undefined>
32	_TRACE_GROUP_LABEL = Process Group [{0}]	32	_TRACE_GROUP_LABEL = Trace Group [{0}]
33	_EDIT_PROFILING_OPTIONS = Edit Profiling Options	33	_EDIT_PROFILING_OPTIONS = Edit Profiling Options
34		34
35	#Monitor statistics view messages	35	#Monitor statistics view messages
36	# MEM_ALLOCATION_DETAILS_FOR = Allocation details for	36	# MEM_ALLOCATION_DETAILS_FOR = Allocation details for
37	_LEGEND = Legend	37	_LEGEND = Legend
38	_TRACE_STATES = Process states	38	_TRACE_STATES = Trace states
39	_WINDOW_TITLE = Process Visualizer's Legend	39	_WINDOW_TITLE = Trace Visualizer's Legend

Lines 18-31 Link Here

(-)src/org/eclipse/linuxtools/tmf/ui/viewers/timeAnalysis/widgets/Utils.java (-12 / +9 lines)
18	import java.text.SimpleDateFormat;	18	import java.text.SimpleDateFormat;
19	import java.util.Date;	19	import java.util.Date;
20	import java.util.Iterator;	20	import java.util.Iterator;
21	import java.util.List;
22	import java.util.TimeZone;	21	import java.util.TimeZone;
23	import java.util.Vector;
24		22
25	import org.eclipse.linuxtools.tmf.ui.viewers.timeAnalysis.ITimeAnalysisViewer.TimeFormat;	23	import org.eclipse.linuxtools.tmf.ui.viewers.timeAnalysis.ITimeAnalysisViewer.TimeFormat;
26	import org.eclipse.linuxtools.tmf.ui.viewers.timeAnalysis.model.ITimeEvent;	24	import org.eclipse.linuxtools.tmf.ui.viewers.timeAnalysis.model.ITimeEvent;
27	import org.eclipse.linuxtools.tmf.ui.viewers.timeAnalysis.model.ITmfTimeAnalysisEntry;	25	import org.eclipse.linuxtools.tmf.ui.viewers.timeAnalysis.model.ITmfTimeAnalysisEntry;
28	import org.eclipse.linuxtools.tmf.ui.viewers.timeAnalysis.model.TimeEvent;
29	import org.eclipse.swt.graphics.Color;	26	import org.eclipse.swt.graphics.Color;
30	import org.eclipse.swt.graphics.Device;	27	import org.eclipse.swt.graphics.Device;
31	import org.eclipse.swt.graphics.GC;	28	import org.eclipse.swt.graphics.GC;
Lines 323-333 Link Here
323	static ITimeEvent getFirstEvent(ITmfTimeAnalysisEntry thread) {	320	static ITimeEvent getFirstEvent(ITmfTimeAnalysisEntry thread) {
324	if (null == thread)	321	if (null == thread)
325	return null;	322	return null;
326	Vector<TimeEvent> list = thread.getTraceEvents();	323	Iterator<ITimeEvent> iterator = thread.getTraceEventsIterator();
327	ITimeEvent event = null;	324	if (iterator.hasNext()) {
328	if (!list.isEmpty())	325	return iterator.next();
329	event = (ITimeEvent) list.get(0);	326	} else {
330	return event;	327	return null;
		328	}
331	}	329	}
332		330
333	/**	331	/**
Lines 343-356 Link Here
343	static ITimeEvent findEvent(ITmfTimeAnalysisEntry thread, long time, int n) {	341	static ITimeEvent findEvent(ITmfTimeAnalysisEntry thread, long time, int n) {
344	if (null == thread)	342	if (null == thread)
345	return null;	343	return null;
346	List<TimeEvent> list = thread.getTraceEvents();	344	Iterator<ITimeEvent> iterator = thread.getTraceEventsIterator();
347	Iterator<TimeEvent> it = list.iterator();
348	ITimeEvent nextEvent = null;	345	ITimeEvent nextEvent = null;
349	ITimeEvent currEvent = null;	346	ITimeEvent currEvent = null;
350	ITimeEvent prevEvent = null;	347	ITimeEvent prevEvent = null;
351		348
352	while (it.hasNext()) {	349	while (iterator.hasNext()) {
353	nextEvent = (ITimeEvent) it.next();	350	nextEvent = (ITimeEvent) iterator.next();
354	long nextStartTime = nextEvent.getTime();	351	long nextStartTime = nextEvent.getTime();
355		352
356	if (nextStartTime > time) {	353	if (nextStartTime > time) {

Lines 107-134 Link Here

(-)src/org/eclipse/linuxtools/tmf/ui/viewers/timeAnalysis/widgets/TmfTimeTipHandler.java (-14 / +16 lines)
107	Item item) {	107	Item item) {
108	if (item instanceof TraceItem) {	108	if (item instanceof TraceItem) {
109	ITmfTimeAnalysisEntry thrd = ((TraceItem) item)._trace;	109	ITmfTimeAnalysisEntry thrd = ((TraceItem) item)._trace;
110	ITimeEvent threadEvent = Utils.findEvent(thrd, threadStates	110	ITimeEvent threadEvent = Utils.findEvent(thrd, threadStates.hitTimeTest(pt.x), 2);
111	.hitTimeTest(pt.x, pt.y), 2);	111	ITimeEvent nextEvent = Utils.findEvent(thrd, threadStates.hitTimeTest(pt.x), 1);
112	ITimeEvent nextEvent = Utils.findEvent(thrd, threadStates
113	.hitTimeTest(pt.x, pt.y), 1);
114	// thread name	112	// thread name
115	addItem(Messages._TRACE_NAME, thrd.getName());	113	addItem(Messages._TRACE_NAME, thrd.getName());
116	// class name	114	// class name
117	addItem(Messages._TRACE_CLASS_NAME, _utilImp	115	String traceClass = _utilImp.getTraceClassName(thrd);
118	.getTraceClassName(thrd));	116	if (traceClass != null) {
		117	addItem(Messages._TRACE_CLASS_NAME, traceClass);
		118	}
119	// thread state	119	// thread state
120	addItem(Messages._TRACE_STATE, _utilImp	120	String state = _utilImp.getEventName(threadEvent);
121	.getEventName(threadEvent));	121	if (state != null) {
		122	addItem(Messages._TRACE_STATE, state);
		123	}
122		124
123	// This block receives a	125	// This block receives a
124	// list of <String, String> values to be added to the tip	126	// list of <String, String> values to be added to the tip
125	// table	127	// table
126	Map<String, String> eventAddOns = _utilImp	128	Map<String, String> eventAddOns = _utilImp.getEventHoverToolTipInfo(threadEvent);
127	.getEventHoverToolTipInfo(threadEvent);	129	if (eventAddOns != null) {
128	for (Iterator<String> iter = eventAddOns.keySet()	130	for (Iterator<String> iter = eventAddOns.keySet().iterator(); iter.hasNext();) {
129	.iterator(); iter.hasNext();) {	131	String message = (String) iter.next();
130	String message = (String) iter.next();	132	addItem(message, eventAddOns.get(message));
131	addItem(message, eventAddOns.get(message));	133	}
132	}	134	}
133		135
134	long eventStartTime = -1;	136	long eventStartTime = -1;

Line 0 Link Here

(-)src/org/eclipse/linuxtools/tmf/ui/views/timechart/TimeChartAnalysisProvider.java (+36 lines)
	1	package org.eclipse.linuxtools.tmf.ui.views.timechart;
	2
	3	import java.util.Map;
	4
	5	import org.eclipse.linuxtools.tmf.ui.viewers.timeAnalysis.TmfTimeAnalysisProvider;
	6	import org.eclipse.linuxtools.tmf.ui.viewers.timeAnalysis.model.ITimeEvent;
	7	import org.eclipse.linuxtools.tmf.ui.viewers.timeAnalysis.model.ITmfTimeAnalysisEntry;
	8
	9	public class TimeChartAnalysisProvider extends TmfTimeAnalysisProvider {
	10
	11	@Override
	12	public StateColor getEventColor(ITimeEvent event) {
	13	return StateColor.MAGENTA3;
	14	}
	15
	16	@Override
	17	public String getTraceClassName(ITmfTimeAnalysisEntry entry) {
	18	return null;
	19	}
	20
	21	@Override
	22	public String getEventName(ITimeEvent event, boolean upper, boolean extInfo) {
	23	return null;
	24	}
	25
	26	@Override
	27	public Map<String, String> getEventHoverToolTipInfo(ITimeEvent event) {
	28	return null;
	29	}
	30
	31	@Override
	32	public String getStateName(StateColor color) {
	33	return null;
	34	}
	35
	36	}

Line 0 Link Here

(-)src/org/eclipse/linuxtools/tmf/ui/views/timechart/TimeChartEvent.java (+159 lines)
		1	package org.eclipse.linuxtools.tmf.ui.views.timechart;
		2
		3	import java.util.ArrayList;
		4	import java.util.Iterator;
		5
		6	import org.eclipse.linuxtools.tmf.event.TmfEvent;
		7	import org.eclipse.linuxtools.tmf.ui.viewers.timeAnalysis.model.ITimeEvent;
		8	import org.eclipse.linuxtools.tmf.ui.viewers.timeAnalysis.model.ITmfTimeAnalysisEntry;
		9
		10	public class TimeChartEvent implements ITimeEvent {
		11
		12	private static final byte TIMESTAMP_SCALE = -9;
		13
		14	private TimeChartAnalysisEntry fParentEntry;
		15	private long fTime;
		16	private long fDuration;
		17	private long fFirstRank;
		18	private long fLastRank;
		19	private RankRangeList fRankRangeList;
		20	private long fNbEvents;
		21	private TimeChartAnalysisEntry fItemizedEntry;
		22	private boolean fItemizing;
		23
		24	public TimeChartEvent(TimeChartAnalysisEntry parentEntry, TmfEvent event, long rank) {
		25	fParentEntry = parentEntry;
		26	fTime = event.getTimestamp().synchronize((long) 0, TIMESTAMP_SCALE).getValue();
		27	fDuration = 0;
		28	fFirstRank = fLastRank = rank;
		29	fRankRangeList = new RankRangeList(rank);
		30	fNbEvents = 1;
		31	}
		32
		33	public ITmfTimeAnalysisEntry getEntry() {
		34	return fParentEntry;
		35	}
		36
		37	public long getTime() {
		38	return fTime;
		39	}
		40
		41	public long getDuration() {
		42	return fDuration;
		43	}
		44
		45	public long getFirstRank() {
		46	return fFirstRank;
		47	}
		48
		49	public long getLastRank() {
		50	return fLastRank;
		51	}
		52
		53	public RankRangeList getRankRangeList() {
		54	return fRankRangeList;
		55	}
		56
		57	public void merge(TimeChartEvent event) {
		58	if (fTime == event.getTime() && fDuration == event.getDuration()) return;
		59	long endTime = Math.max(fTime + fDuration, event.getTime() + event.getDuration());
		60	fTime = Math.min(fTime, event.getTime());
		61	fDuration = endTime - fTime;
		62	fFirstRank = Math.min(fFirstRank, event.fFirstRank);
		63	fLastRank = Math.max(fLastRank, event.fLastRank);
		64	fNbEvents += event.fNbEvents;
65	fItemizedEntry = null;
66	fRankRangeList.merge(event.getRankRangeList());
67	}
68
69	public long getNbEvents() {
70	return fNbEvents;
71	}
72
73	public void setItemizedEntry(TimeChartAnalysisEntry timeAnalysisEntry) {
74	fItemizedEntry = timeAnalysisEntry;
75	}
76
77	public TimeChartAnalysisEntry getItemizedEntry() {
78	return fItemizedEntry;
79	}
80
81	public boolean isItemizing() {
82	return fItemizing;
83	}
84
85	public void setItemizing(boolean itemizing) {
86	fItemizing = itemizing;
87	}
88
89	public class RankRange {
90	private long firstRank;
91	private long lastRank;
92
93	public RankRange(long firstRank, long lastRank) {
94	this.firstRank = firstRank;
95	this.lastRank = lastRank;
96	}
97
98	public long getFirstRank() {
99	return firstRank;
100	}
101
102	public long getLastRank() {
103	return lastRank;
104	}
105
106	public long distanceFrom(RankRange range) {
107	if (range.lastRank < fFirstRank) {
108	return fFirstRank - range.lastRank;
109	} else if (range.firstRank > fLastRank) {
110	return range.firstRank - fLastRank;
111	} else {
112	return 0;
113	}
114	}
115
116	public String toString() {
117	return "["+firstRank+","+lastRank+"]";
118	}
119	}
120
121	private class RankRangeList extends ArrayList<RankRange> {
122
123	private static final long serialVersionUID = 6060485531208535986L;
124
125	public RankRangeList(long rank) {
126	super(1);
127	add(new RankRange(rank, rank));
128	}
129
130	public void merge(RankRangeList rankRangeList) {
131	long threshold = fParentEntry.getTrace().getCacheSize();
132	for (RankRange newRange : rankRangeList) {
133	boolean merged = false;
134	for (RankRange oldRange : fRankRangeList) {
135	if (newRange.distanceFrom(oldRange) <= threshold) {
136	oldRange.firstRank = Math.min(oldRange.firstRank, newRange.firstRank);
137	oldRange.lastRank = Math.max(oldRange.lastRank, newRange.lastRank);
138	merged = true;
139	break;
140	}
141	}
142	if (!merged) {
143	add(newRange);
144	}
145	}
146	Iterator<RankRange> iterator = fRankRangeList.iterator();
147	RankRange previous = null;
148	while (iterator.hasNext()) {
149	RankRange range = iterator.next();
150	if (previous != null && range.distanceFrom(previous) <= threshold) {
151	previous.firstRank = Math.min(previous.firstRank, range.firstRank);
152	previous.lastRank = Math.max(previous.lastRank, range.lastRank);
153	iterator.remove();
154	}
155	previous = range;
156	}
157	}
158	}
159	}

Lines 11-20 Link Here

(-)widgetStubs/org/eclipse/linuxtools/tmf/ui/widgets/timeAnalysis/test/stub/model/TraceImpl.java (-5 / +17 lines)
11	*******************************************************************************/	11	*******************************************************************************/
12	package org.eclipse.linuxtools.tmf.ui.widgets.timeAnalysis.test.stub.model;	12	package org.eclipse.linuxtools.tmf.ui.widgets.timeAnalysis.test.stub.model;
13		13
		14	import java.util.Iterator;
14	import java.util.Vector;	15	import java.util.Vector;
15		16
		17	import org.eclipse.linuxtools.tmf.ui.viewers.timeAnalysis.model.ITimeEvent;
16	import org.eclipse.linuxtools.tmf.ui.viewers.timeAnalysis.model.ITmfTimeAnalysisEntry;	18	import org.eclipse.linuxtools.tmf.ui.viewers.timeAnalysis.model.ITmfTimeAnalysisEntry;
17	import org.eclipse.linuxtools.tmf.ui.viewers.timeAnalysis.model.TimeEvent;
18		19
19		20
20	public class TraceImpl implements ITmfTimeAnalysisEntry {	21	public class TraceImpl implements ITmfTimeAnalysisEntry {
Lines 27-33 Link Here
27	private long stopTime = 1;	28	private long stopTime = 1;
28	private String groupName = "defaultGroupName";	29	private String groupName = "defaultGroupName";
29	private String className = "defaultClassName";	30	private String className = "defaultClassName";
30	private Vector<TimeEvent> traceEvents = new Vector<TimeEvent>();	31	private Vector<ITimeEvent> traceEvents = new Vector<ITimeEvent>();
31		32
32	// ========================================================================	33	// ========================================================================
33	// Constructor	34	// Constructor
Lines 95-103 Link Here
95	return stopTime;	96	return stopTime;
96	}	97	}
97		98
98	@SuppressWarnings("unchecked")	99	@Deprecated public Vector<ITimeEvent> getTraceEvents() {
99	public Vector<TimeEvent> getTraceEvents() {	100	return traceEvents;
100	return traceEvents;
101	}	101	}
		102
		103	public Iterator<ITimeEvent> getTraceEventsIterator() {
		104	return traceEvents.iterator();
		105	}
		106
		107	public Iterator<ITimeEvent> getTraceEventsIterator(long startTime, long stopTime, long maxDuration) {
		108	return traceEvents.iterator();
		109	}
		110
		111	public void addTraceEvent(ITimeEvent event) {
		112	traceEvents.add(event);
		113	}
102		114
103	}	115	}

Lines 35-44 Link Here

(-)widgetStubs/org/eclipse/linuxtools/tmf/ui/widgets/timeAnalysis/test/stub/views/TsfTraceAnalysisView.java (-3 / +1 lines)
35	import org.eclipse.jface.viewers.ViewerSorter;	35	import org.eclipse.jface.viewers.ViewerSorter;
36	import org.eclipse.linuxtools.tmf.ui.viewers.TmfViewerFactory;	36	import org.eclipse.linuxtools.tmf.ui.viewers.TmfViewerFactory;
37	import org.eclipse.linuxtools.tmf.ui.viewers.timeAnalysis.ITimeAnalysisViewer;	37	import org.eclipse.linuxtools.tmf.ui.viewers.timeAnalysis.ITimeAnalysisViewer;
		38	import org.eclipse.linuxtools.tmf.ui.viewers.timeAnalysis.ITmfTimeScaleSelectionListener;
38	import org.eclipse.linuxtools.tmf.ui.viewers.timeAnalysis.ITmfTimeSelectionListener;	39	import org.eclipse.linuxtools.tmf.ui.viewers.timeAnalysis.ITmfTimeSelectionListener;
39	import org.eclipse.linuxtools.tmf.ui.viewers.timeAnalysis.TmfTimeScaleSelectionEvent;	40	import org.eclipse.linuxtools.tmf.ui.viewers.timeAnalysis.TmfTimeScaleSelectionEvent;
40	import org.eclipse.linuxtools.tmf.ui.viewers.timeAnalysis.TmfTimeSelectionEvent;	41	import org.eclipse.linuxtools.tmf.ui.viewers.timeAnalysis.TmfTimeSelectionEvent;
41	import org.eclipse.linuxtools.tmf.ui.viewers.timeAnalysis.ITmfTimeScaleSelectionListener;
42	import org.eclipse.linuxtools.tmf.ui.viewers.timeAnalysis.model.ITmfTimeAnalysisEntry;	42	import org.eclipse.linuxtools.tmf.ui.viewers.timeAnalysis.model.ITmfTimeAnalysisEntry;
43	import org.eclipse.linuxtools.tmf.ui.widgets.timeAnalysis.test.stub.adaption.TsfImplProvider;	43	import org.eclipse.linuxtools.tmf.ui.widgets.timeAnalysis.test.stub.adaption.TsfImplProvider;
44	import org.eclipse.linuxtools.tmf.ui.widgets.timeAnalysis.test.stub.model.EventImpl;	44	import org.eclipse.linuxtools.tmf.ui.widgets.timeAnalysis.test.stub.model.EventImpl;
Lines 633-640 Link Here
633	+ selTrace.getName().toString()	633	+ selTrace.getName().toString()
634	+ "\nClass Name: "	634	+ "\nClass Name: "
635	+ selTrace.getClassName()	635	+ selTrace.getClassName()
636	+ "\nNumber of Events: "
637	+ selTrace.getTraceEvents().size()
638	+ "\nSelection Type: "	636	+ "\nSelection Type: "
639	+ event.getDType().toString()	637	+ event.getDType().toString()
640	+ "\nSelected Time: "	638	+ "\nSelected Time: "