Attachment #189664 for bug #325016

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

Lines 6-11 Link Here

(-)plugin.properties (+1 lines)
6	views.category.name = TMF	6	views.category.name = TMF
7	project.view.name = Projects	7	project.view.name = Projects
8	events.view.name = Events	8	events.view.name = Events
		9	timechart.view.name = Time Chart
9	events.editor.name = Events	10	events.editor.name = Events
10		11
11	wizard.category.name = TMF	12	wizard.category.name = TMF





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

import java.util.List;
import java.util.Map;

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.linuxtools.tmf.ui.viewers.timeAnalysis.widgets.TraceColorScheme;
import org.eclipse.swt.SWT;
import org.eclipse.swt.graphics.GC;

		if (threadClass != null && threadClass.length() > 0) {
			name += " [" + threadClass + "]"; //$NON-NLS-1$ //$NON-NLS-2$
		}
		/*
		 * Check if this is still necessary!
		if (inclState) {
			List<TimeEvent> list = trace.getTraceEvents();
			if (null != list && list.size() > 0) {

				name += " (" + getEventName(event, false, true) + ")"; //$NON-NLS-1$ //$NON-NLS-2$
			}
		}
		*/
		return name;
	}





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

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

import org.eclipse.jface.viewers.ISelection;

	// called from the display order in the API
	public void modelUpdate(ITmfTimeAnalysisEntry[] traces) {
		if (null != _stateCtrl) {
			//loadOptions();
			updateInternalData(traces);
			_stateCtrl.redraw();
			_timeScaleCtrl.redraw();

	public void modelUpdate(ITmfTimeAnalysisEntry[] traces, long start,
			long end, boolean updateTimeBounds) {
		if (null != _stateCtrl) {
			//loadOptions();
			updateInternalData(traces, start, end);
			if (updateTimeBounds) {
				_timeRangeFixed = true;

	void setTimeRange(Object traces[]) {
		_endTime = 0;
		_beginTime = -1;
//		ITimeEvent event;
		for (int i = 0; i < traces.length; i++) {
			ITmfTimeAnalysisEntry entry = (ITmfTimeAnalysisEntry) traces[i];
			if (entry.getStopTime() >= entry.getStartTime() && entry.getStopTime() > 0) {

			        _endTime = entry.getStopTime();
			    }
			}
			/*
			 * This is not needed if entry startTime and stopTime are properly set!
			List<TimeEvent> list = entry.getTraceEvents();
			int len = list.size();
			if (len > 0) {

					_endTime = eventEndTime;
				}
			}
			*/
		}

		if (_beginTime < 0)

			_selectedTime = _endTime;
		if (_selectedTime < _beginTime)
			_selectedTime = _beginTime;
		long time0 = _time0;
		long time1 = _time1;
		if (ensureVisible) {
			double timeSpace = (_time1 - _time0) * .02;
			double timeMid = (_time1 - _time0) * .1;

		_stateCtrl.adjustScrolls();
		_stateCtrl.redraw();
		_timeScaleCtrl.redraw();
		if (time0 != _time0 || time1 != _time1) {
			notifyStartFinishTimeSelectionListeners(_time0, _time1);
		}
	}

	@Override

		}
	}

    @Override
    public void setMinimumItemWidth(int width) {
        if (_stateCtrl != null) {
            _stateCtrl.setMinimumItemWidth(width);
        }
    }
    
	@Override
	public boolean isVisibleVerticalScroll() {
		if (_stateCtrl != null) {





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);
}

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 64-69 Link Here

(-)src/org/eclipse/linuxtools/tmf/ui/viewers/timeAnalysis/widgets/TmfTimeStatesCtrl.java (-144 / +111 lines)
64	*/	64	*/
65	public class TmfTimeStatesCtrl extends TraceCtrl implements FocusListener, KeyListener, MouseMoveListener, MouseListener, MouseWheelListener, ControlListener, SelectionListener, MouseTrackListener, TraverseListener, ISelectionProvider {	65	public class TmfTimeStatesCtrl extends TraceCtrl implements FocusListener, KeyListener, MouseMoveListener, MouseListener, MouseWheelListener, ControlListener, SelectionListener, MouseTrackListener, TraverseListener, ISelectionProvider {
66		66
		67	private static final int DRAG_NONE = 0;
		68	private static final int DRAG_TRACE_ITEM = 1;
		69	private static final int DRAG_GROUP_ITEM = 2;
		70	private static final int DRAG_SPLIT_LINE = 3;
67	public static final boolean DEFAULT_DRAW_THREAD_JOIN = true;	71	public static final boolean DEFAULT_DRAW_THREAD_JOIN = true;
68	public static final boolean DEFAULT_DRAW_THREAD_WAIT = true;	72	public static final boolean DEFAULT_DRAW_THREAD_WAIT = true;
69	public static final boolean DEFAULT_DRAW_THREAD_RELEASE = true;	73	public static final boolean DEFAULT_DRAW_THREAD_RELEASE = true;
Lines 78-85 Link Here
78	private boolean _mouseHover = false;	82	private boolean _mouseHover = false;
79	private int _itemHeightDefault = 19;	83	private int _itemHeightDefault = 19;
80	private int _itemHeight = _itemHeightDefault;	84	private int _itemHeight = _itemHeightDefault;
		85	private int _minimumItemWidth = 0;
81	private int _topItem = 0;	86	private int _topItem = 0;
82	private int _dragState = 0;	87	private int _dragState = DRAG_NONE;
83	private int _hitIdx = 0;	88	private int _hitIdx = 0;
84	private int _dragX0 = 0;	89	private int _dragX0 = 0;
85	private int _dragX = 0;	90	private int _dragX = 0;
Lines 132-145 Link Here
132	if (scrollHor != null) {	137	if (scrollHor != null) {
133	scrollHor.addSelectionListener(this);	138	scrollHor.addSelectionListener(this);
134	}	139	}
135	mouseScrollFilterListener = new Listener() {
136	// This filter is used to prevent scrolling of the view when the
137	// mouse wheel is used to zoom
138	@Override
139	public void handleEvent(Event event) {
140	event.doit = false;
141	}
142	};
143		140
144	_dragCursor3 = new Cursor(super.getDisplay(), SWT.CURSOR_SIZEWE);	141	_dragCursor3 = new Cursor(super.getDisplay(), SWT.CURSOR_SIZEWE);
145	_WaitCursor = new Cursor(super.getDisplay(), SWT.CURSOR_WAIT);	142	_WaitCursor = new Cursor(super.getDisplay(), SWT.CURSOR_WAIT);
Lines 451-457 Link Here
451	if (zoomIn) {	448	if (zoomIn) {
452	newInterval = Math.max(Math.round((double) interval * 0.8), _timeProvider.getMinTimeInterval());	449	newInterval = Math.max(Math.round((double) interval * 0.8), _timeProvider.getMinTimeInterval());
453	} else {	450	} else {
454	newInterval = Math.round((double) interval * 1.25);	451	newInterval = (long) Math.ceil((double) interval * 1.25);
455	}	452	}
456	long center = time0 + Math.round(((double) (xPos - nameSpace) / timeSpace * interval));	453	long center = time0 + Math.round(((double) (xPos - nameSpace) / timeSpace * interval));
457	long newTime0 = center - Math.round((double) newInterval * (center - time0) / interval);	454	long newTime0 = center - Math.round((double) newInterval * (center - time0) / interval);
Lines 621-627 Link Here
621	return idx >= 0 ? (Item) _data._items[idx] : null;	618	return idx >= 0 ? (Item) _data._items[idx] : null;
622	}	619	}
623		620
624	long hitTimeTest(int x, int y) {	621	long hitTimeTest(int x) {
625	if (null == _timeProvider)	622	if (null == _timeProvider)
626	return -1;	623	return -1;
627	long hitTime = -1;	624	long hitTime = -1;
Lines 644-668 Link Here
644	}	641	}
645		642
646	void selectItem(int idx, boolean addSelection) {	643	void selectItem(int idx, boolean addSelection) {
		644	boolean changed = false;
647	if (addSelection) {	645	if (addSelection) {
648	if (idx >= 0 && idx < _data._items.length) {	646	if (idx >= 0 && idx < _data._items.length) {
649	Item item = (Item) _data._items[idx];	647	Item item = (Item) _data._items[idx];
		648	changed = (item._selected == false);
650	item._selected = true;	649	item._selected = true;
651	}	650	}
652	} else {	651	} else {
653	for (int i = 0; i < _data._items.length; i++) {	652	for (int i = 0; i < _data._items.length; i++) {
654	Item item = (Item) _data._items[i];	653	Item item = (Item) _data._items[i];
		654	if (i == idx && item._selected == false) {
		655	changed = true;
		656	}
655	item._selected = i == idx;	657	item._selected = i == idx;
656	}	658	}
657	}	659	}
658	boolean changed = ensureVisibleItem(idx, true);	660	changed \|= ensureVisibleItem(idx, true);
659	if (!changed)	661	if (changed)
660	redraw();	662	redraw();
661	}	663	}
662		664
663	public void selectItem(ITmfTimeAnalysisEntry trace, boolean addSelection) {	665	public void selectItem(ITmfTimeAnalysisEntry trace, boolean addSelection) {
664	Integer idx = _data.findTraceItemIndex(trace);	666	Integer idx = _data.findTraceItemIndex(trace);
665	selectItem(idx, addSelection);	667	if (idx != null) {
		668	selectItem(idx, addSelection);
		669	}
666	}	670	}
667		671
668	public int countPerPage() {	672	public int countPerPage() {
Lines 946-956 Link Here
946	if (drawTracesInteraction)	950	if (drawTracesInteraction)
947	drawTraceInteractions(bound, e.gc);	951	drawTraceInteractions(bound, e.gc);
948		952
		953	// draw empty name space background
		954	if (_itemHeight * items.length < bound.height) {
		955	gc.setBackground(_colors.getBkColor(false, false, true));
		956	drawBackground(gc, bound.x, _itemHeight * items.length, nameWidth, bound.height - _itemHeight * items.length);
		957	}
		958
949	// draw drag line, no line if name space is 0.	959	// draw drag line, no line if name space is 0.
950	if (3 == _dragState) {	960	if (DRAG_SPLIT_LINE == _dragState) {
951	gc.setForeground(_colors.getColor(TraceColorScheme.BLACK));	961	gc.setForeground(_colors.getColor(TraceColorScheme.BLACK));
952	gc.drawLine(bound.x + nameWidth, bound.y, bound.x + nameWidth, bound.y + bound.height - 1);	962	gc.drawLine(bound.x + nameWidth, bound.y, bound.x + nameWidth, bound.y + bound.height - 1);
953	} else if (0 == _dragState && _mouseHover && _timeProvider.getNameSpace() > 0) {	963	} else if (DRAG_NONE == _dragState && _mouseHover && _timeProvider.getNameSpace() > 0) {
954	gc.setForeground(_colors.getColor(TraceColorScheme.RED));	964	gc.setForeground(_colors.getColor(TraceColorScheme.RED));
955	gc.drawLine(bound.x + nameWidth, bound.y, bound.x + nameWidth, bound.y + bound.height - 1);	965	gc.drawLine(bound.x + nameWidth, bound.y, bound.x + nameWidth, bound.y + bound.height - 1);
956	}	966	}
Lines 1066-1077 Link Here
1066	ITmfTimeAnalysisEntry trace = ((TraceItem) item)._trace;	1076	ITmfTimeAnalysisEntry trace = ((TraceItem) item)._trace;
1067		1077
1068	int x0 = rect.x;	1078	int x0 = rect.x;
1069	List<TimeEvent> list = trace.getTraceEvents();	1079	Iterator<ITimeEvent> iterator = trace.getTraceEventsIterator();
1070	// Iterator it = list.iterator();
1071	int count = list.size();
1072	ITimeEvent lastEvent = null;	1080	ITimeEvent lastEvent = null;
1073	if (count > 0) {	1081	if (iterator.hasNext()) {
1074	ITimeEvent currEvent = list.get(0);	1082	ITimeEvent currEvent = iterator.next();
1075	ITimeEvent nextEvent = null;	1083	ITimeEvent nextEvent = null;
1076	long currEventTime = currEvent.getTime();	1084	long currEventTime = currEvent.getTime();
1077	long nextEventTime = currEventTime;	1085	long nextEventTime = currEventTime;
Lines 1083-1096 Link Here
1083	// reduce rect	1091	// reduce rect
1084	_rect1.y += 3;	1092	_rect1.y += 3;
1085	_rect1.height -= 6;	1093	_rect1.height -= 6;
1086	fillSpace(rect, gc, selected, _rect1.x, x0, xEnd);	1094	fillSpace(rect, gc, selected);
1087		1095
1088	// draw event states	1096	// draw event states
1089	while (x0 <= xEnd && null != currEvent) {	1097	while (x0 <= xEnd && null != currEvent) {
1090	boolean stopped = false;// currEvent instanceof	1098	boolean stopped = false;// currEvent instanceof
1091	// TsfTmTraceDeadEvent;	1099	// TsfTmTraceDeadEvent;
1092	if (idx < count) {	1100	if (iterator.hasNext()) {
1093	nextEvent = list.get(idx);	1101	nextEvent = iterator.next();
1094	nextEventTime = nextEvent.getTime();	1102	nextEventTime = nextEvent.getTime();
1095	idx++;	1103	idx++;
1096	} else if (stopped) {	1104	} else if (stopped) {
Lines 1133-1154 Link Here
1133	gc.drawLine(_rect1.x, midy, _rect1.x + _rect1.width, midy);	1141	gc.drawLine(_rect1.x, midy, _rect1.x + _rect1.width, midy);
1134	gc.setLineWidth(lw);	1142	gc.setLineWidth(lw);
1135	}	1143	}
1136
1137	// draw focus ares
1138	Utils.init(_rect1, rect);
1139	gc.setForeground(_colors.getBkColor(selected, _isInFocus, false));
1140	int y = _rect1.y;
1141	gc.drawLine(_rect1.x, y, _rect1.x + _rect1.width, y);
1142	y++;
1143	gc.drawLine(_rect1.x, y, _rect1.x + _rect1.width, y);
1144	y++;
1145	gc.drawLine(_rect1.x, y, _rect1.x + _rect1.width, y);
1146	y = _rect1.y + _rect1.height - 1;
1147	gc.drawLine(_rect1.x, y, _rect1.x + _rect1.width, y);
1148	y--;
1149	gc.drawLine(_rect1.x, y, _rect1.x + _rect1.width, y);
1150	y--;
1151	gc.drawLine(_rect1.x, y, _rect1.x + _rect1.width, y);
1152	}	1144	}
1153		1145
1154	// draw selected time	1146	// draw selected time
Lines 1205-1217 Link Here
1205	ITmfTimeAnalysisEntry trace = ((TraceItem) item)._trace;	1197	ITmfTimeAnalysisEntry trace = ((TraceItem) item)._trace;
1206		1198
1207	double x0 = rect.x;	1199	double x0 = rect.x;
1208	List<TimeEvent> list = trace.getTraceEvents();	1200	Iterator<ITimeEvent> iterator = trace.getTraceEventsIterator();
1209	// Iterator it = list.iterator();
1210	int count = list.size();
1211	ITimeEvent lastEvent = null;	1201	ITimeEvent lastEvent = null;
1212	// Trace.debug("count is: " + count);	1202	// Trace.debug("count is: " + count);
1213	if (count > 0) {	1203	if (iterator.hasNext()) {
1214	ITimeEvent currEvent = list.get(0);	1204	ITimeEvent currEvent = iterator.next();
1215	ITimeEvent nextEvent = null;	1205	ITimeEvent nextEvent = null;
1216	long currEventTime = currEvent.getTime();	1206	long currEventTime = currEvent.getTime();
1217	long nextEventTime = currEventTime;	1207	long nextEventTime = currEventTime;
Lines 1222-1241 Link Here
1222	double xEnd = rect.x + (double) ((time1 - time0) * pixelsPerNanoSec);	1212	double xEnd = rect.x + (double) ((time1 - time0) * pixelsPerNanoSec);
1223	double x1 = -1;	1213	double x1 = -1;
1224	int idx = 1;	1214	int idx = 1;
1225	double xNext = 0;	1215	//double xNext = 0;
1226		1216
1227	// Drawing rectangle is smaller than reserved space	1217	// Drawing rectangle is smaller than reserved space
1228	_rect1.y += 3;	1218	_rect1.y += 3;
1229	_rect1.height -= 6;	1219	_rect1.height -= 6;
1230		1220
1231	// Clean up to empty line to draw on top	1221	// Clean up to empty line to draw on top
1232	fillSpace(rect, gc, selected, _rect1.x, xEnd, xEnd);	1222	fillSpace(rect, gc, selected);
1233	// draw event states	1223	// draw event states
1234	while (x0 <= xEnd && null != currEvent) {	1224	while (x0 <= xEnd && null != currEvent) {
1235	boolean stopped = false;// currEvent instanceof	1225	boolean stopped = false;// currEvent instanceof
1236	// TsfTmTraceDeadEvent;	1226	// TsfTmTraceDeadEvent;
1237	if (idx < count) {	1227	if (iterator.hasNext()) {
1238	nextEvent = list.get(idx);	1228	nextEvent = iterator.next();
1239	nextEventTime = nextEvent.getTime();	1229	nextEventTime = nextEvent.getTime();
1240	idx++;	1230	idx++;
1241	} else if (stopped) {	1231	} else if (stopped) {
Lines 1265-1274 Link Here
1265	// with space until next event	1255	// with space until next event
1266	_rect1.x += _rect1.width;	1256	_rect1.x += _rect1.width;
1267	x0 = x1;	1257	x0 = x1;
1268	xNext = rect.x + (double) ((nextEventTime - time0) * pixelsPerNanoSec);	1258	//xNext = rect.x + (double) ((nextEventTime - time0) * pixelsPerNanoSec);
1269	}	1259	}
1270	// Fill space till next event	1260	// Fill space till next event
1271	fillSpace(rect, gc, selected, x0, xNext, xEnd);	1261	fillSpace(rect, gc, selected);
1272		1262
1273	lastEvent = currEvent;	1263	lastEvent = currEvent;
1274	currEvent = nextEvent;	1264	currEvent = nextEvent;
Lines 1299-1320 Link Here
1299	gc.drawLine(_rect1.x, midy, _rect1.x + _rect1.width, midy);	1289	gc.drawLine(_rect1.x, midy, _rect1.x + _rect1.width, midy);
1300	gc.setLineWidth(lw);	1290	gc.setLineWidth(lw);
1301	}	1291	}
1302
1303	// draw focus area
1304	Utils.init(_rect1, rect);
1305	gc.setForeground(_colors.getBkColor(selected, _isInFocus, false));
1306	int y = _rect1.y;
1307	gc.drawLine(_rect1.x, y, _rect1.x + _rect1.width, y);
1308	y++;
1309	gc.drawLine(_rect1.x, y, _rect1.x + _rect1.width, y);
1310	y++;
1311	gc.drawLine(_rect1.x, y, _rect1.x + _rect1.width, y);
1312	y = _rect1.y + _rect1.height - 1;
1313	gc.drawLine(_rect1.x, y, _rect1.x + _rect1.width, y);
1314	y--;
1315	gc.drawLine(_rect1.x, y, _rect1.x + _rect1.width, y);
1316	y--;
1317	gc.drawLine(_rect1.x, y, _rect1.x + _rect1.width, y);
1318	}	1292	}
1319		1293
1320	// draw selected time	1294	// draw selected time
Lines 1370-1379 Link Here
1370	ITmfTimeAnalysisEntry trace = ((TraceItem) item)._trace;	1344	ITmfTimeAnalysisEntry trace = ((TraceItem) item)._trace;
1371		1345
1372	double x0 = rect.x;	1346	double x0 = rect.x;
1373	@SuppressWarnings("unchecked")	1347	long maxDuration = (_timeProvider.getTimeSpace() == 0) ? Long.MAX_VALUE : 1 * (_timeProvider.getTime1() - _timeProvider.getTime0()) / _timeProvider.getTimeSpace();
1374	List<TimeEvent> list = (List<TimeEvent>) trace.getTraceEvents().clone();	1348	Iterator<ITimeEvent> iterator = trace.getTraceEventsIterator(_timeProvider.getTime0(), _timeProvider.getTime1(), maxDuration);
1375	// Iterator it = list.iterator();
1376	int count = list.size();
1377	// ITimeEvent lastEvent = null;	1349	// ITimeEvent lastEvent = null;
1378	// if (Trace.isDEBUG()) {	1350	// if (Trace.isDEBUG()) {
1379	// Trace.debug("\n\t\t\tTrace: " + trace.getName()	1351	// Trace.debug("\n\t\t\tTrace: " + trace.getName()
Lines 1386-1394 Link Here
1386		1358
1387	// Clean up to empty line to draw on top	1359	// Clean up to empty line to draw on top
1388	int xEnd = rect.x + rect.width;	1360	int xEnd = rect.x + rect.width;
1389	fillSpace(rect, gc, selected, _rect1.x, xEnd, xEnd);	1361	fillSpace(rect, gc, selected);
1390	if (count > 0) {	1362	if (iterator.hasNext()) {
1391	ITimeEvent currEvent = list.get(0);	1363	ITimeEvent currEvent = iterator.next();
1392	ITimeEvent nextEvent = null;	1364	ITimeEvent nextEvent = null;
1393	long currEventTime = currEvent.getTime();	1365	long currEventTime = currEvent.getTime();
1394	long currEventDuration = currEvent.getDuration();	1366	long currEventDuration = currEvent.getDuration();
Lines 1408-1415 Link Here
1408	// refresh current event duration as the loop moves	1380	// refresh current event duration as the loop moves
1409	currEventDuration = currEvent.getDuration();	1381	currEventDuration = currEvent.getDuration();
1410	// TsfTmTraceDeadEvent;	1382	// TsfTmTraceDeadEvent;
1411	if (idx < count) {	1383	if (iterator.hasNext()) {
1412	nextEvent = list.get(idx);	1384	nextEvent = iterator.next();
1413	nextEventTime = nextEvent.getTime();	1385	nextEventTime = nextEvent.getTime();
1414	idx++;	1386	idx++;
1415	} else if (stopped) {	1387	} else if (stopped) {
Lines 1448-1458 Link Here
1448	if (x1 >= rect.x && x0 <= xEnd) {	1420	if (x1 >= rect.x && x0 <= xEnd) {
1449	if (currEventDuration != 0) {	1421	if (currEventDuration != 0) {
1450	x0 = (double) (x0 >= rect.x ? x0 : rect.x);	1422	x0 = (double) (x0 >= rect.x ? x0 : rect.x);
1451	_rect1.width = (int) ((x1 <= xEnd ? x1 : xEnd) - x0);	1423	_rect1.width = (int) Math.ceil(x1 <= xEnd ? x1 : xEnd) - (int) x0;
1452	} else {	1424	} else {
1453	_rect1.width = 2; // make punctual events 2 pixels	1425	_rect1.width = 1;
1454	// wide
1455	}	1426	}
		1427	_rect1.width = Math.max(_minimumItemWidth, _rect1.width);
1456	_rect1.x = (int) x0;	1428	_rect1.x = (int) x0;
1457	boolean timeSelected = currEventTime <= selectedTime && selectedTime < nextEventTime;	1429	boolean timeSelected = currEventTime <= selectedTime && selectedTime < nextEventTime;
1458	utilImpl.drawState(_colors, currEvent, _rect1, gc, selected, false, timeSelected);	1430	utilImpl.drawState(_colors, currEvent, _rect1, gc, selected, false, timeSelected);
Lines 1480-1501 Link Here
1480	// + K + " = " + x0);	1452	// + K + " = " + x0);
1481	}	1453	}
1482	}	1454	}
1483
1484	// draw focus area
1485	Utils.init(_rect1, rect);
1486	gc.setForeground(_colors.getBkColor(selected, _isInFocus, false));
1487	int y = _rect1.y;
1488	gc.drawLine(_rect1.x, y, _rect1.x + _rect1.width, y);
1489	y++;
1490	gc.drawLine(_rect1.x, y, _rect1.x + _rect1.width, y);
1491	y++;
1492	gc.drawLine(_rect1.x, y, _rect1.x + _rect1.width, y);
1493	y = _rect1.y + _rect1.height - 1;
1494	gc.drawLine(_rect1.x, y, _rect1.x + _rect1.width, y);
1495	y--;
1496	gc.drawLine(_rect1.x, y, _rect1.x + _rect1.width, y);
1497	y--;
1498	gc.drawLine(_rect1.x, y, _rect1.x + _rect1.width, y);
1499	}	1455	}
1500		1456
1501	// draw selected time	1457	// draw selected time
Lines 1509-1535 Link Here
1509	}	1465	}
1510	}	1466	}
1511		1467
1512	private void fillSpace(Rectangle rect, GC gc, boolean selected, double x0, double x1, double xEnd) {	1468	private void fillSpace(Rectangle rect, GC gc, boolean selected) {
1513	// fill space before first event	1469	gc.setBackground(_colors.getBkColor(selected, _isInFocus, false));
1514	if (x0 >= rect.x && x0 < xEnd) {	1470	gc.fillRectangle(rect);
1515	// _rect1.width = (int) ((x1 <= xEnd ? x1 : xEnd) - x0);	1471	// draw middle line
1516	// Trace.debug("Drawing Space: " + _rect1.x + "," + _rect1.y + ","	1472	gc.setForeground(_colors.getColor(TraceColorScheme.MID_LINE));
1517	// + _rect1.height + ", " + _rect1.width + "--> "	1473	int midy = rect.y + rect.height / 2;
1518	// + ((int) _rect1.x + (int) _rect1.width));	1474	gc.drawLine(rect.x, midy, rect.x + rect.width, midy);
1519
1520	// if (_rect1.width < 0) {
1521	// Trace.debug("Incorrect width:" + _rect1.width);
1522	// }
1523	gc.setBackground(_colors.getBkColor(selected, _isInFocus, false));
1524	gc.fillRectangle(_rect1);
1525	// draw middle line
1526	gc.setForeground(_colors.getColor(TraceColorScheme.MID_LINE));
1527	int midy = _rect1.y + _rect1.height / 2;
1528	gc.drawLine(_rect1.x, midy, _rect1.x + _rect1.width, midy);
1529	} else {
1530	// Trace.debug("No space added since, x0 is out of range " + x0
1531	// + " rect.x: " + rect.x + " xEnd: " + xEnd);
1532	}
1533	}	1475	}
1534		1476
1535	@Override	1477	@Override
Lines 1601-1618 Link Here
1601	public void focusGained(FocusEvent e) {	1543	public void focusGained(FocusEvent e) {
1602	_isInFocus = true;	1544	_isInFocus = true;
1603	redraw();	1545	redraw();
1604	getDisplay().addFilter(SWT.MouseWheel, mouseScrollFilterListener);	1546	if (mouseScrollFilterListener == null) {
		1547	mouseScrollFilterListener = new Listener() {
		1548	// This filter is used to prevent scrolling of the view when the
		1549	// mouse wheel is used to zoom
		1550	@Override
		1551	public void handleEvent(Event event) {
		1552	event.doit = false;
		1553	}
		1554	};
		1555	getDisplay().addFilter(SWT.MouseWheel, mouseScrollFilterListener);
		1556	}
1605	}	1557	}
1606		1558
1607	@Override	1559	@Override
1608	public void focusLost(FocusEvent e) {	1560	public void focusLost(FocusEvent e) {
1609	_isInFocus = false;	1561	_isInFocus = false;
1610	if (0 != _dragState) {	1562	if (DRAG_NONE != _dragState) {
1611	setCapture(false);	1563	setCapture(false);
1612	_dragState = 0;	1564	_dragState = DRAG_NONE;
1613	}	1565	}
1614	redraw();	1566	redraw();
1615	getDisplay().removeFilter(SWT.MouseWheel, mouseScrollFilterListener);	1567	if (mouseScrollFilterListener != null) {
		1568	getDisplay().removeFilter(SWT.MouseWheel, mouseScrollFilterListener);
		1569	mouseScrollFilterListener = null;
		1570	}
1616	}	1571	}
1617		1572
1618	public boolean isInFocus() {	1573	public boolean isInFocus() {
Lines 1624-1630 Link Here
1624	if (null == _timeProvider)	1579	if (null == _timeProvider)
1625	return;	1580	return;
1626	Point size = getCtrlSize();	1581	Point size = getCtrlSize();
1627	if (1 == _dragState) {	1582	if (DRAG_TRACE_ITEM == _dragState) {
1628	int nameWidth = _timeProvider.getNameSpace();	1583	int nameWidth = _timeProvider.getNameSpace();
1629	int x = e.x - nameWidth;	1584	int x = e.x - nameWidth;
1630	if (x > 0 && size.x > nameWidth && _dragX != x) {	1585	if (x > 0 && size.x > nameWidth && _dragX != x) {
Lines 1642-1651 Link Here
1642	}	1597	}
1643	_timeProvider.setStartFinishTime(time0, time1);	1598	_timeProvider.setStartFinishTime(time0, time1);
1644	}	1599	}
1645	} else if (3 == _dragState) {	1600	} else if (DRAG_SPLIT_LINE == _dragState) {
1646	_dragX = e.x;	1601	_dragX = e.x;
1647	_timeProvider.setNameSpace(_hitIdx + _dragX - _dragX0);	1602	_timeProvider.setNameSpace(_hitIdx + _dragX - _dragX0);
1648	} else if (0 == _dragState) {	1603	} else if (DRAG_NONE == _dragState) {
1649	boolean mouseHover = hitSplitTest(e.x, e.y) > 0;	1604	boolean mouseHover = hitSplitTest(e.x, e.y) > 0;
1650	if (_mouseHover != mouseHover)	1605	if (_mouseHover != mouseHover)
1651	redraw();	1606	redraw();
Lines 1734-1740 Link Here
1734	if (namewidth != 0) {	1689	if (namewidth != 0) {
1735	idx = hitSplitTest(e.x, e.y);	1690	idx = hitSplitTest(e.x, e.y);
1736	if (idx > 0) {	1691	if (idx > 0) {
1737	_dragState = 3;	1692	_dragState = DRAG_SPLIT_LINE;
1738	_dragX = _dragX0 = e.x;	1693	_dragX = _dragX0 = e.x;
1739	_hitIdx = _timeProvider.getNameSpace();	1694	_hitIdx = _timeProvider.getNameSpace();
1740	;	1695	;
Lines 1748-1789 Link Here
1748	idx = hitTest(e.x, e.y);	1703	idx = hitTest(e.x, e.y);
1749	if (idx >= 0) {	1704	if (idx >= 0) {
1750	if (_data._items[idx] instanceof TraceItem) {	1705	if (_data._items[idx] instanceof TraceItem) {
1751	long hitTime = hitTimeTest(e.x, e.y);	1706	long hitTime = hitTimeTest(e.x);
1752	if (hitTime >= 0) {	1707	if (hitTime >= 0) {
1753	_timeProvider.setSelectedTimeInt(hitTime, false);	1708	// _timeProvider.setSelectedTimeInt(hitTime, false);
1754	setCapture(true);	1709	setCapture(true);
1755	_dragState = 1;	1710	_dragState = DRAG_TRACE_ITEM;
1756	_dragX = _dragX0 = e.x - _timeProvider.getNameSpace();	1711	_dragX = _dragX0 = e.x - _timeProvider.getNameSpace();
		1712	_hitIdx = idx;
1757	_time0bak = _timeProvider.getTime0();	1713	_time0bak = _timeProvider.getTime0();
1758	_time1bak = _timeProvider.getTime1();	1714	_time1bak = _timeProvider.getTime1();
		1715	return;
1759	}	1716	}
1760	} else if (_data._items[idx] instanceof GroupItem) {	1717	} else if (_data._items[idx] instanceof GroupItem) {
1761	_hitIdx = idx;	1718	_dragX0 = e.x;
1762	_dragState = 2;	1719	_dragState = DRAG_GROUP_ITEM;
1763	}	1720	}
1764	selectItem(idx, false);	1721	selectItem(idx, false);
1765	fireSelectionChanged();	1722	fireSelectionChanged();
1766	} else {	1723	} else {
1767	selectItem(idx, false); // clear selection	1724	selectItem(idx, false); // clear selection
		1725	redraw();
1768	}	1726	}
1769	}	1727	}
1770	}	1728	}
1771		1729
1772	@Override	1730	@Override
1773	public void mouseUp(MouseEvent e) {	1731	public void mouseUp(MouseEvent e) {
1774	if (0 != _dragState) {	1732	if (DRAG_NONE != _dragState) {
1775	setCapture(false);	1733	setCapture(false);
1776	if (1 == _dragState) {	1734	if (DRAG_TRACE_ITEM == _dragState) {
1777	// Notify time provider to check the need for listener	1735	// Notify time provider to check the need for listener
1778	// notification	1736	// notification
1779	_timeProvider.notifyStartFinishTime();	1737	_timeProvider.notifyStartFinishTime();
1780	} else if (2 == _dragState) {	1738	if (_dragX == _dragX0) { // click without drag
1781	if (hitTest(e.x, e.y) == _hitIdx)	1739	long time = hitTimeTest(e.x);
		1740	_timeProvider.setSelectedTimeInt(time, false);
		1741	selectItem(_hitIdx, false);
		1742	fireSelectionChanged();
		1743	}
		1744	} else if (DRAG_GROUP_ITEM == _dragState) {
		1745	if (e.x == _dragX0) // click without drag
1782	toggle(_hitIdx);	1746	toggle(_hitIdx);
1783	} else if (3 == _dragState) {	1747	} else if (DRAG_SPLIT_LINE == _dragState) {
1784	redraw();	1748	redraw();
1785	}	1749	}
1786	_dragState = 0;	1750	_dragState = DRAG_NONE;
1787	}	1751	}
1788	}	1752	}
1789		1753
Lines 1849-1855 Link Here
1849		1813
1850	@Override	1814	@Override
1851	public void mouseScrolled(MouseEvent e) {	1815	public void mouseScrolled(MouseEvent e) {
1852	if (!_isInFocus)	1816	if (!_isInFocus \|\| _dragState != DRAG_NONE)
1853	return;	1817	return;
1854	if (e.count > 0) {	1818	if (e.count > 0) {
1855	zoom(true);	1819	zoom(true);
Lines 1895-1900 Link Here
1895	this._itemHeight = rowHeight;	1859	this._itemHeight = rowHeight;
1896	}	1860	}
1897		1861
		1862	public void setMinimumItemWidth(int width) {
		1863	this._minimumItemWidth = width;
		1864	}
		1865
1898	public Vector<ITmfTimeAnalysisEntry> getFilteredOut() {	1866	public Vector<ITmfTimeAnalysisEntry> getFilteredOut() {
1899	return _data.getFilteredOut();	1867	return _data.getFilteredOut();
1900	}	1868	}
Lines 2033-2053 Link Here
2033	if (trace == null)	2001	if (trace == null)
2034	return null;	2002	return null;
2035		2003
2036	int traceId = trace.getId();
2037
2038	Integer idx = null;
2039	for (int i = 0; i < _items.length; i++) {	2004	for (int i = 0; i < _items.length; i++) {
2040	idx = i;
2041	Object item = _items[i];	2005	Object item = _items[i];
2042	if (item instanceof TraceItem) {	2006	if (item instanceof TraceItem) {
2043	TraceItem ti = (TraceItem) item;	2007	TraceItem ti = (TraceItem) item;
2044	if (ti._trace.getId() == traceId) {	2008	if (ti._trace == trace) {
2045	break;	2009	return i;
2046	}	2010	}
2047	}	2011	}
2048	}	2012	}
2049		2013
2050	return idx;	2014	return null;
2051	}	2015	}
2052		2016
2053	public void updateItems() {	2017	public void updateItems() {
Lines 2109-2115 Link Here
2109	*/	2073	*/
2110	public void refreshPartial(ITmfTimeAnalysisEntry parent, TimeEvent childItem) {	2074	public void refreshPartial(ITmfTimeAnalysisEntry parent, TimeEvent childItem) {
2111	// Find the Trace item within the current list	2075	// Find the Trace item within the current list
2112	TraceItem item = findTraceItem(parent);	2076	// TraceItem item = findTraceItem(parent);
2113		2077
2114	// This method is not used (yet) so this code can be commented out for	2078	// This method is not used (yet) so this code can be commented out for
2115	// now	2079	// now
Lines 2142-2147 Link Here
2142	// item = findTraceItem(parent);	2106	// item = findTraceItem(parent);
2143	// }	2107	// }
2144		2108
		2109	/*
		2110	* Check if this is still needed!
2145	ITmfTimeAnalysisEntry localTraceItem = item._trace;	2111	ITmfTimeAnalysisEntry localTraceItem = item._trace;
2146	// Local trace found	2112	// Local trace found
2147	Vector<TimeEvent> children = localTraceItem.getTraceEvents();	2113	Vector<TimeEvent> children = localTraceItem.getTraceEvents();
Lines 2157-2162 Link Here
2157	}	2123	}
2158	// Add the new item	2124	// Add the new item
2159	children.add(childItem);	2125	children.add(childItem);
		2126	*/
2160		2127
2161	}	2128	}
2162		2129

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
					addItem(Messages._TRACE_CLASS_NAME, _utilImp
							.getTraceClassName(thrd));
					// thread state
					addItem(Messages._TRACE_STATE, _utilImp
							.getEventName(threadEvent));

					// 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;

Lines 22-27 Link Here

(-)META-INF/MANIFEST.MF (+1 lines)
22	org.eclipse.linuxtools.tmf.ui.viewers.timeAnalysis.model,	22	org.eclipse.linuxtools.tmf.ui.viewers.timeAnalysis.model,
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




            name="%events.view.name"
            restorable="true">
      </view>
      <view
            category="org.eclipse.linuxtools.tmf.ui.views.category"
            class="org.eclipse.linuxtools.tmf.ui.views.timechart.TimeChartView"
            icon="icons/eview16/timechart_view.gif"
            id="org.eclipse.linuxtools.tmf.ui.views.timechart"
            name="%timechart.view.name"
            restorable="true">
      </view>
   </extension>
   <extension
         point="org.eclipse.ui.editors">

   <extension
         point="org.eclipse.core.contenttype.contentTypes">
      <content-type
            file-extensions="log"
            id="org.eclipse.linuxtools.tmf.ui.content-type.trace"
            name="%contenttype.trace"
            priority="normal">




/*******************************************************************************
 * Copyright (c) 2010 Ericsson
 * 
 * All rights reserved. This program and the accompanying materials are
 * made available under the terms of the Eclipse Public License v1.0 which
 * accompanies this distribution, and is available at
 * http://www.eclipse.org/legal/epl-v10.html
 * 
 * Contributors:
 *   Patrick Tasse - Initial API and implementation
 *******************************************************************************/

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;
    }
    
    @Override
    public String getGroupName() {
        return fGroup;
    }

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

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

    @Override
    public long getStartTime() {
        return fStartTime;
    }

    @Override
    public long getStopTime() {
        return fStopTime;
    }

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

    @Override
    public Iterator<ITimeEvent> getTraceEventsIterator() {
        return new EntryIterator(0, Long.MAX_VALUE, 0);
    }
    
    @Override
    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;
        }
        
        @Override
        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;
            }
        }

        @Override
        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();
            }
        }

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

    @Override
    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 = (int) ((time - fReferenceTime) >> fPower);
                }
                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);
                index = (int) ((time - fReferenceTime) >> fPower);
                fTraceEvents.setSize((int) index + 1);
            }
            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.mergeDecorations((TimeChartEvent) timeEvent);
                    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;
    }
}




/*******************************************************************************
 * Copyright (c) 2010 Ericsson
 * 
 * All rights reserved. This program and the accompanying materials are
 * made available under the terms of the Eclipse Public License v1.0 which
 * accompanies this distribution, and is available at
 * http://www.eclipse.org/legal/epl-v10.html
 * 
 * Contributors:
 *   Patrick Tasse - Initial API and implementation
 *******************************************************************************/

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;
import org.eclipse.linuxtools.tmf.ui.viewers.timeAnalysis.widgets.TraceColorScheme;
import org.eclipse.linuxtools.tmf.ui.views.colors.ColorSettingsManager;
import org.eclipse.swt.SWT;
import org.eclipse.swt.graphics.Color;
import org.eclipse.swt.graphics.GC;
import org.eclipse.swt.graphics.Rectangle;
import org.eclipse.swt.widgets.Display;

public class TimeChartAnalysisProvider extends TmfTimeAnalysisProvider {

	private static final Color BOOKMARK_INNER_COLOR = new Color(Display.getDefault(), 115, 165, 224);
	private static final Color BOOKMARK_OUTER_COLOR = new Color(Display.getDefault(), 2, 70, 140);
	private static final Color SEARCH_MATCH_COLOR = new Color(Display.getDefault(), 177, 118, 14);
	
	private int lastX = Integer.MIN_VALUE;
	private int currX = Integer.MIN_VALUE;
	private int lastPriority;
	private int lastBookmarkX = Integer.MIN_VALUE;
	
    @Override
    public StateColor getEventColor(ITimeEvent event) {
        return StateColor.BLACK;
    }

    @Override
    public int getEventColorVal(ITimeEvent event) {
		int priority = ((TimeChartEvent) event).getColorSettingPriority();
		if (currX == lastX) {
			priority = Math.min(priority, lastPriority);
		}
		lastPriority = priority;
		return ColorSettingsManager.getColorSetting(priority).getTickColorIndex();
    }

	@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;
    }

    @Override
    public void drawState(TraceColorScheme colors, ITimeEvent event, Rectangle rect, GC gc, boolean selected, boolean rectBound, boolean timeSelected) {
	    if (! ((TimeChartEvent) event).isVisible()) {
	    	return;
	    }
    	lastX = currX;
    	currX = rect.x;
	    super.drawState(colors, event, rect, gc, selected, rectBound, timeSelected);
	    if (lastBookmarkX == rect.x || ((TimeChartEvent) event).isBookmarked()) {
	    	drawBookmark(rect, gc);
	    	lastBookmarkX = rect.x;
	    } else if (lastBookmarkX == rect.x - 1) {
	    	Rectangle r = new Rectangle(lastBookmarkX, rect.y, rect.width, rect.height);
	    	drawBookmark(r, gc);
	    } else {
	    	lastBookmarkX = Integer.MIN_VALUE;
	    }
	    if (((TimeChartEvent) event).isSearchMatch()) {
	    	drawSearchMatch(rect, gc);
	    }
    }

    private void drawBookmark(Rectangle r, GC gc) {
    	gc.setForeground(BOOKMARK_OUTER_COLOR);
    	gc.drawLine(r.x - 1, r.y - 2, r.x - 1, r.y + 2);
    	gc.drawLine(r.x + 1, r.y - 2, r.x + 1, r.y + 2);
    	gc.drawPoint(r.x, r.y - 2);
    	gc.setForeground(BOOKMARK_INNER_COLOR);
    	gc.drawLine(r.x, r.y - 1, r.x, r.y + 1);
    	gc.setForeground(Display.getDefault().getSystemColor(SWT.COLOR_WHITE));
    	gc.drawPoint(r.x - 1, r.y + 3);
    	gc.drawPoint(r.x, r.y + 2);
    	gc.drawPoint(r.x + 1, r.y + 3);
    }
    
    private void drawSearchMatch(Rectangle r, GC gc) {
    	gc.setForeground(SEARCH_MATCH_COLOR);
    	gc.drawPoint(r.x, r.y + r.height);
    	gc.drawLine(r.x - 1, r.y + r.height + 1, r.x + 1, r.y + r.height + 1);
    	gc.drawLine(r.x - 2, r.y + r.height + 2, r.x + 2, r.y + r.height + 2);
    }
}




/*******************************************************************************
 * Copyright (c) 2010 Ericsson
 * 
 * All rights reserved. This program and the accompanying materials are
 * made available under the terms of the Eclipse Public License v1.0 which
 * accompanies this distribution, and is available at
 * http://www.eclipse.org/legal/epl-v10.html
 * 
 * Contributors:
 *   Patrick Tasse - Initial API and implementation
 *******************************************************************************/

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

import java.util.HashSet;
import java.util.Set;

import org.eclipse.core.resources.IMarker;
import org.eclipse.core.resources.IResource;
import org.eclipse.core.runtime.CoreException;
import org.eclipse.linuxtools.tmf.event.TmfEvent;
import org.eclipse.linuxtools.tmf.filter.ITmfFilter;

public class TimeChartDecorationProvider {

	private IResource fResource;
    private Set<Long> fBookmarksSet = new HashSet<Long>();
    private ITmfFilter fFilterFilter;
    private ITmfFilter fSearchFilter;

	public TimeChartDecorationProvider(IResource resource) {
	    fResource = resource;
	    refreshBookmarks();
    }

	public IResource getResource() {
		return fResource;
	}
	
	public boolean isBookmark(long rank) {
	    return fBookmarksSet.contains(rank);
    }
	
	public void refreshBookmarks() {
		try {
			fBookmarksSet.clear();
	        for (IMarker bookmark : fResource.findMarkers(IMarker.BOOKMARK, false, IResource.DEPTH_ZERO)) {
	        	int location = bookmark.getAttribute(IMarker.LOCATION, -1);
	        	if (location != -1) {
	        		Long rank = (long) location;
	        		fBookmarksSet.add(rank);
	        	}
	        }
        } catch (CoreException e) {
	        e.printStackTrace();
        }
    }

	public void filterApplied(ITmfFilter filter) {
		fFilterFilter = filter;
    }

	public boolean isVisible(TmfEvent event) {
		if (fFilterFilter != null) {
			return fFilterFilter.matches(event);
		}
		return true;
	}
	
	public void searchApplied(ITmfFilter filter) {
		fSearchFilter = filter;
    }
	
	public boolean isSearchMatch(TmfEvent event) {
		if (fSearchFilter != null) {
			return fSearchFilter.matches(event);
		}
		return false;
	}
	
}




/*******************************************************************************
 * Copyright (c) 2010 Ericsson
 * 
 * All rights reserved. This program and the accompanying materials are
 * made available under the terms of the Eclipse Public License v1.0 which
 * accompanies this distribution, and is available at
 * http://www.eclipse.org/legal/epl-v10.html
 * 
 * Contributors:
 *   Patrick Tasse - Initial API and implementation
 *******************************************************************************/

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;
import org.eclipse.linuxtools.tmf.ui.views.colors.ColorSettingsManager;

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 int fColorSettingPriority;
    private boolean fIsBookmark;
    private boolean fIsVisible;
    private boolean fIsSearchMatch;
    private TimeChartAnalysisEntry fItemizedEntry;
    private boolean fItemizing;

    public TimeChartEvent(TimeChartAnalysisEntry parentEntry, TmfEvent event, long rank, TimeChartDecorationProvider decorationProvider) {
        fParentEntry = parentEntry;
        fTime = event.getTimestamp().synchronize((long) 0, TIMESTAMP_SCALE).getValue();
        fDuration = 0;
        fFirstRank = fLastRank = rank;
        fRankRangeList = new RankRangeList(rank);
        fNbEvents = 1;
        fColorSettingPriority = ColorSettingsManager.getColorSettingPriority(event);
        fIsBookmark = decorationProvider.isBookmark(rank);
        fIsVisible = decorationProvider.isVisible(event);
        fIsSearchMatch = decorationProvider.isSearchMatch(event);
    }

	@Override
    public ITmfTimeAnalysisEntry getEntry() {
        return fParentEntry;
    }

    @Override
    public long getTime() {
        return fTime;
    }

    @Override
    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) {
    	mergeDecorations(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;
        synchronized (fRankRangeList) {
        	fRankRangeList.merge(event.getRankRangeList());
        }
    }

    public void mergeDecorations(TimeChartEvent event) {
        fColorSettingPriority = Math.min(fColorSettingPriority, event.getColorSettingPriority());
        fIsBookmark |= event.fIsBookmark;
    	fIsVisible |= event.fIsVisible;
    	fIsSearchMatch |= event.fIsSearchMatch;
    }
    
    public long getNbEvents() {
        return fNbEvents;
    }

    public int getColorSettingPriority() {
    	return fColorSettingPriority;
    }
    
    public void setColorSettingPriority(int priority) {
    	fColorSettingPriority = priority;
    }
    
    public boolean isBookmarked() {
    	return fIsBookmark;
    }

    public void setIsBookmarked(boolean isBookmarked) {
    	fIsBookmark = isBookmarked;
    }
    
    public boolean isVisible() {
    	return fIsVisible;
    }

    public void setIsVisible(boolean isVisible) {
    	fIsVisible = isVisible;
    }
    
    public boolean isSearchMatch() {
    	return fIsSearchMatch;
    }

    public void setIsSearchMatch(boolean isSearchMatch) {
    	fIsSearchMatch = isSearchMatch;
    }
    
    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;
            }
        }
        
        @Override
        public String toString() {
            return "["+firstRank+","+lastRank+"]"; //$NON-NLS-1$ //$NON-NLS-2$ //$NON-NLS-3$
        }
    }
    
    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;
            }
        }
    }
}




/*******************************************************************************
 * Copyright (c) 2010 Ericsson
 * 
 * All rights reserved. This program and the accompanying materials are
 * made available under the terms of the Eclipse Public License v1.0 which
 * accompanies this distribution, and is available at
 * http://www.eclipse.org/legal/epl-v10.html
 * 
 * Contributors:
 *   Patrick Tasse - Initial API and implementation
 *******************************************************************************/

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

import java.util.ArrayList;
import java.util.HashMap;
import java.util.Iterator;
import java.util.Map;

import org.eclipse.core.resources.IMarker;
import org.eclipse.core.resources.IMarkerDelta;
import org.eclipse.core.resources.IResource;
import org.eclipse.core.resources.IResourceChangeEvent;
import org.eclipse.core.resources.IResourceChangeListener;
import org.eclipse.core.resources.IResourceDelta;
import org.eclipse.core.resources.ResourcesPlugin;
import org.eclipse.linuxtools.tmf.event.TmfEvent;
import org.eclipse.linuxtools.tmf.event.TmfTimestamp;
import org.eclipse.linuxtools.tmf.filter.ITmfFilter;
import org.eclipse.linuxtools.tmf.signal.TmfSignalHandler;
import org.eclipse.linuxtools.tmf.signal.TmfTimeSynchSignal;
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.signal.TmfTraceClosedSignal;
import org.eclipse.linuxtools.tmf.ui.signal.TmfTraceOpenedSignal;
import org.eclipse.linuxtools.tmf.ui.viewers.TmfViewerFactory;
import org.eclipse.linuxtools.tmf.ui.viewers.events.ITmfEventsFilterListener;
import org.eclipse.linuxtools.tmf.ui.viewers.events.ITmfEventsFilterProvider;
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.colors.ColorSetting;
import org.eclipse.linuxtools.tmf.ui.views.colors.ColorSettingsManager;
import org.eclipse.linuxtools.tmf.ui.views.colors.IColorSettingsListener;
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, IColorSettingsListener, IResourceChangeListener, ITmfEventsFilterListener {

    public static final String ID = "org.eclipse.linuxtools.tmf.ui.views.timechart"; //$NON-NLS-1$

    private static final byte TIMESTAMP_SCALE = -9;
    
    private int fDisplayWidth;
    private Composite fComposite;
    private ITimeAnalysisViewer fViewer;
    private ArrayList<TimeChartAnalysisEntry> fTimeAnalysisEntries = new ArrayList<TimeChartAnalysisEntry>();
    private Map<ITmfTrace, TimeChartDecorationProvider> fDecorationProviders = new HashMap<ITmfTrace, TimeChartDecorationProvider>();
    private ArrayList<DecorateThread> fDecorateThreads;
    private long fStartTime = 0;
    private long fStopTime = Long.MAX_VALUE;

    public TimeChartView() {
        super("Time Chart"); //$NON-NLS-1$
        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);
        
        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) {
                    IResource resource = ((ITmfTraceEditor) editor).getResource();
                    TimeChartAnalysisEntry timeAnalysisEntry = new TimeChartAnalysisEntry(trace, fDisplayWidth * 2);
                    fTimeAnalysisEntries.add(timeAnalysisEntry);
                    fDecorationProviders.put(trace, new TimeChartDecorationProvider(resource));
                    Thread thread = new ProcessTraceThread(timeAnalysisEntry);
                    thread.start();
                }
            }
        }
        fViewer.display(fTimeAnalysisEntries.toArray(new TimeChartAnalysisEntry[0]));
        
        fDecorateThreads = new ArrayList<DecorateThread>();
        ColorSettingsManager.addColorSettingsListener(this);
        ResourcesPlugin.getWorkspace().addResourceChangeListener(this, IResourceChangeEvent.POST_CHANGE);
    }

    @Override
    public void dispose() {
    	ResourcesPlugin.getWorkspace().removeResourceChangeListener(this);
    	for (DecorateThread thread : fDecorateThreads) {
    		thread.cancel();
    	}
        ColorSettingsManager.removeColorSettingsListener(this);
	    super.dispose();
    }

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

        private TimeChartAnalysisEntry fTimeAnalysisEntry;

        public ProcessTraceThread(TimeChartAnalysisEntry timeAnalysisEntry) {
            super("ProcessTraceJob:"+timeAnalysisEntry.getName()); //$NON-NLS-1$
            fTimeAnalysisEntry = timeAnalysisEntry;
        }

        @Override
        public void run() {
            updateTraceEntry(fTimeAnalysisEntry, Long.MAX_VALUE, 0, Long.MAX_VALUE);
        }
    }
    
    private void updateTraceEntry(TimeChartAnalysisEntry timeAnalysisEntry, long stopRank, long startTime, long stopTime) {
        ITmfTrace trace = timeAnalysisEntry.getTrace();
        TimeChartDecorationProvider decorationProvider = fDecorationProviders.get(trace);
        if (decorationProvider == null) {
        	return; // the trace has been closed
        }
        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, decorationProvider);
                    if (timeEvent.getTime() >= startTime && timeEvent.getTime() <= stopTime) {
                        timeAnalysisEntry.addTraceEvent(timeEvent);
                    }
                    //lastTimestamp = event.getTimestamp();
                    //} *** commented out so that color setting priority gets set even if the event has same time
                    if (context.getRank() == trace.getNbEvents() || context.getRank() == stopRank) {
                        done = true;
                        break;
                    }
                    if (context.getRank() % trace.getCacheSize() == 1) {
                    	// break for UI refresh
                        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() {
            @Override
            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++) {
            Thread thread = new ItemizeThread(fTimeAnalysisEntries.get(i), startTime, stopTime);
            thread.start();
        }
    }
    
    private class ItemizeThread extends Thread {

        private TimeChartAnalysisEntry fTimeAnalysisEntry;
        private long fStartTime;
        private long fStopTime;
        private long fMaxDuration;
        
        private ItemizeThread(TimeChartAnalysisEntry timeAnalysisEntry, long startTime, long stopTime) {
            super("Itemize Thread:"+timeAnalysisEntry.getName()); //$NON-NLS-1$
            fTimeAnalysisEntry = timeAnalysisEntry;
            fStartTime = startTime;
            fStopTime = stopTime;
            fMaxDuration =  3 * (fStopTime - fStartTime) / fDisplayWidth;
        }
        
        @Override
        public void run() {
            itemizeTraceEntry(fTimeAnalysisEntry);
        }

        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(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));
            synchronized (event.getRankRangeList()) {
            	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);
            }
        }
    }

    private void redecorate() {
    	synchronized (fDecorateThreads) {
	        for (DecorateThread thread : fDecorateThreads) {
		        thread.cancel();
	        }
	        fDecorateThreads.clear();
	        for (int i = 0; i < fTimeAnalysisEntries.size(); i++) {
		        DecorateThread thread = new DecorateThread(fTimeAnalysisEntries.get(i));
		        thread.start();
		        fDecorateThreads.add(thread);
	        }
        }
    }
    
    private class DecorateThread extends Thread {
		private volatile boolean interrupted = false;
        private TimeChartAnalysisEntry fTimeAnalysisEntry;
        private TimeChartDecorationProvider fDecorationProvider;
        private TmfContext fContext;
        private int fCount = 0;
        
        private DecorateThread(TimeChartAnalysisEntry timeAnalysisEntry) {
            super("Decorate Thread:"+timeAnalysisEntry.getName()); //$NON-NLS-1$
            fTimeAnalysisEntry = timeAnalysisEntry;
            fDecorationProvider = fDecorationProviders.get(timeAnalysisEntry.getTrace());
        }
        
        @Override
        public void run() {
        	resetTraceEntry(fTimeAnalysisEntry);
            refreshViewer(false);
            decorateTraceEntry(fTimeAnalysisEntry, null);
            refreshViewer(false);
        	synchronized (fDecorateThreads) {
        		fDecorateThreads.remove(this);
        	}
        }

        public void resetTraceEntry(TimeChartAnalysisEntry timeAnalysisEntry) {
            Iterator<ITimeEvent> iterator = timeAnalysisEntry.getTraceEventsIterator();
            TimeChartEvent event = null;
            boolean hasNext = true;
            while (!interrupted && hasNext) {
                synchronized (timeAnalysisEntry) {
                    while (hasNext = iterator.hasNext()) {
                        event = (TimeChartEvent) iterator.next();
                        break;
                    }
                }
                if (hasNext) {
                	// TODO possible concurrency problem here with ItemizeJob
                	event.setColorSettingPriority(ColorSettingsManager.PRIORITY_NONE);
                    if (event.getItemizedEntry() != null) {
                    	resetTraceEntry(event.getItemizedEntry());
                    }
                }
            }
        }
        
        public void decorateTraceEntry(TimeChartAnalysisEntry timeAnalysisEntry, TimeChartEvent parentEvent) {
        	// Set max duration high to ensure iterator does not consider itemized events
            Iterator<ITimeEvent> iterator = timeAnalysisEntry.getTraceEventsIterator(0, Long.MAX_VALUE, Long.MAX_VALUE);
            TimeChartEvent event = null;
            int entryPriority = ColorSettingsManager.PRIORITY_NONE;
            boolean entryIsBookmarked = false;
            boolean entryIsVisible = false;
            boolean entryIsSearchMatch = false;
            boolean hasNext = true;
            while (!interrupted && hasNext) {
                synchronized (timeAnalysisEntry) {
                    while (hasNext = iterator.hasNext()) {
                        event = (TimeChartEvent) iterator.next();
                        break;
                    }
                }
                if (hasNext) {
                	// TODO possible concurrency problem here with ItemizeJob
                    if (event.getItemizedEntry() == null) {
                        decorateEvent(event);
                    } else {
                        decorateTraceEntry(event.getItemizedEntry(), event);
                    }
                    entryPriority = Math.min(entryPriority, event.getColorSettingPriority());
                    entryIsBookmarked |= event.isBookmarked();
                    entryIsVisible |= event.isVisible();
                    entryIsSearchMatch |= event.isSearchMatch();
                    if (++fCount % timeAnalysisEntry.getTrace().getCacheSize() == 0) {
                        refreshViewer(false);
                    }
                }
            }
            if (parentEvent != null) {
            	parentEvent.setColorSettingPriority(entryPriority);
        		parentEvent.setIsBookmarked(entryIsBookmarked);
        		parentEvent.setIsVisible(entryIsVisible);
        		parentEvent.setIsSearchMatch(entryIsSearchMatch);
            }
        }

        public void decorateEvent(TimeChartEvent timeChartEvent) {
        	// TODO possible concurrency problem here with ItemizeJob
        	TimeChartAnalysisEntry timeAnalysisEntry = (TimeChartAnalysisEntry) timeChartEvent.getEntry();
        	ITmfTrace trace = timeAnalysisEntry.getTrace();
        	int priority = ColorSettingsManager.PRIORITY_NONE;
        	boolean isBookmarked = false;
        	boolean isVisible = false;
        	boolean isSearchMatch = false;
            synchronized (timeChartEvent.getRankRangeList()) {
            	for (RankRange range : timeChartEvent.getRankRangeList()) {
            		if (interrupted) return;
            		if (fContext == null || fContext.getRank() != range.getFirstRank()) {
            			fContext = trace.seekEvent(range.getFirstRank());
            			fContext.setRank(range.getFirstRank());
            		}
                    while (true) {
                		if (interrupted) return;
                		long rank = fContext.getRank();
                        TmfEvent event = trace.getNextEvent(fContext);
                        if (event == null) {
                            break;
                        }
                        long eventTime = event.getTimestamp().synchronize(0, (byte) -9).getValue();
                        if (eventTime >= timeChartEvent.getTime() && eventTime <= timeChartEvent.getTime() + timeChartEvent.getDuration()) {
                        	priority = Math.min(priority, ColorSettingsManager.getColorSettingPriority(event));
                        }
                        isBookmarked |= fDecorationProvider.isBookmark(rank); 
                        isVisible |= fDecorationProvider.isVisible(event); 
                        isSearchMatch |= fDecorationProvider.isSearchMatch(event); 
                        if (fContext.getRank() > range.getLastRank()) {
                        	break;
                        }
                    }
            	}
            }
            timeChartEvent.setColorSettingPriority(priority);
            timeChartEvent.setIsBookmarked(isBookmarked);
            timeChartEvent.setIsVisible(isVisible);
            timeChartEvent.setIsSearchMatch(isSearchMatch);
        }
		
		public void cancel() {
			interrupted = true;
		}
    }

    // ------------------------------------------------------------------------
    // Listeners
    // ------------------------------------------------------------------------
    
    @Override
    public void tsfTmProcessTimeScaleEvent(TmfTimeScaleSelectionEvent event) {
    	fStartTime = event.getTime0();
    	fStopTime = event.getTime1();
        itemize(fStartTime, fStopTime);
    }

    @Override
    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)));
    }

	@Override
    public void colorSettingsChanged(ColorSetting[] colorSettings) {
		redecorate();
    }

    @Override
    public void resourceChanged(IResourceChangeEvent event) {
		for (IMarkerDelta delta : event.findMarkerDeltas(IMarker.BOOKMARK, false)) {
			for (TimeChartDecorationProvider provider : fDecorationProviders.values()) {
				if (delta.getResource().equals(provider.getResource())) {
					if (delta.getKind() == IResourceDelta.CHANGED && delta.getMarker().getAttribute(IMarker.LOCATION, -1) != -1) {
						provider.refreshBookmarks();
					} else if (delta.getKind() == IResourceDelta.REMOVED) {
						provider.refreshBookmarks();
					}
				}
			}
		}
		redecorate();
    }
	
	@Override
    public void filterApplied(ITmfFilter filter, ITmfTrace trace) {
		TimeChartDecorationProvider decorationProvider = fDecorationProviders.get(trace);
		decorationProvider.filterApplied(filter);
		redecorate();
    }

	@Override
    public void searchApplied(ITmfFilter filter, ITmfTrace trace) {
		TimeChartDecorationProvider decorationProvider = fDecorationProviders.get(trace);
		decorationProvider.searchApplied(filter);
		redecorate();
    }

    // ------------------------------------------------------------------------
    // Signal handlers
    // ------------------------------------------------------------------------
    
	@TmfSignalHandler
    public void traceOpened(TmfTraceOpenedSignal signal) {
        if (fTimeAnalysisEntries == null) return;
        final ITmfTrace trace = signal.getTrace();
        final IResource resource = signal.getResource();
        final ITmfEventsFilterProvider eventsFilterProvider = signal.getEventsFilterProvider();
        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);
            fDecorationProviders.put(trace, new TimeChartDecorationProvider(resource));
            Thread thread = new ProcessTraceThread(timeAnalysisEntry);
            thread.start();
        }
        refreshViewer(true);
        if (eventsFilterProvider != null) {
        	eventsFilterProvider.addEventsFilterListener(this);
        }
    }
    
    @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);
                fDecorationProviders.remove(trace);
                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 84-90 Link Here

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




 *******************************************************************************/
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;

@SuppressWarnings("nls")
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

	}

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

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

    @Override
    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;

		viewer.getControl().setFocus();
	}

	@SuppressWarnings("deprecation")
    @Override
	public void tsfTmProcessSelEvent(TmfTimeSelectionEvent event) {
		Object source = event.getSource();
		if (source == null || !(source instanceof ITimeAnalysisViewer)) {

Return to bug 325016

Lines 12-23 Link Here

(-)src/org/eclipse/linuxtools/tmf/ui/viewers/timeAnalysis/TmfTimeAnalysisProvider.java (-2 / +3 lines)
12		12
13	package org.eclipse.linuxtools.tmf.ui.viewers.timeAnalysis;	13	package org.eclipse.linuxtools.tmf.ui.viewers.timeAnalysis;
14		14
15	import java.util.List;
16	import java.util.Map;	15	import java.util.Map;
17		16
18	import org.eclipse.linuxtools.tmf.ui.viewers.timeAnalysis.model.ITimeEvent;	17	import org.eclipse.linuxtools.tmf.ui.viewers.timeAnalysis.model.ITimeEvent;
19	import org.eclipse.linuxtools.tmf.ui.viewers.timeAnalysis.model.ITmfTimeAnalysisEntry;	18	import org.eclipse.linuxtools.tmf.ui.viewers.timeAnalysis.model.ITmfTimeAnalysisEntry;
20	import org.eclipse.linuxtools.tmf.ui.viewers.timeAnalysis.model.TimeEvent;
21	import org.eclipse.linuxtools.tmf.ui.viewers.timeAnalysis.widgets.TraceColorScheme;	19	import org.eclipse.linuxtools.tmf.ui.viewers.timeAnalysis.widgets.TraceColorScheme;
22	import org.eclipse.swt.SWT;	20	import org.eclipse.swt.SWT;
23	import org.eclipse.swt.graphics.GC;	21	import org.eclipse.swt.graphics.GC;
Lines 274-279 Link Here
274	if (threadClass != null && threadClass.length() > 0) {	272	if (threadClass != null && threadClass.length() > 0) {
275	name += " [" + threadClass + "]"; //$NON-NLS-1$ //$NON-NLS-2$	273	name += " [" + threadClass + "]"; //$NON-NLS-1$ //$NON-NLS-2$
276	}	274	}
		275	/*
		276	* Check if this is still necessary!
277	if (inclState) {	277	if (inclState) {
278	List<TimeEvent> list = trace.getTraceEvents();	278	List<TimeEvent> list = trace.getTraceEvents();
279	if (null != list && list.size() > 0) {	279	if (null != list && list.size() > 0) {
Lines 281-286 Link Here
281	name += " (" + getEventName(event, false, true) + ")"; //$NON-NLS-1$ //$NON-NLS-2$	281	name += " (" + getEventName(event, false, true) + ")"; //$NON-NLS-1$ //$NON-NLS-2$
282	}	282	}
283	}	283	}
		284	*/
284	return name;	285	return name;
285	}	286	}
286		287

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 (-10 / +8 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	addItem(Messages._TRACE_CLASS_NAME, _utilImp
118	.getTraceClassName(thrd));	116	.getTraceClassName(thrd));
119	// thread state	117	// thread state
120	addItem(Messages._TRACE_STATE, _utilImp	118	addItem(Messages._TRACE_STATE, _utilImp
121	.getEventName(threadEvent));	119	.getEventName(threadEvent));
122		120
123	// This block receives a	121	// This block receives a
124	// list of <String, String> values to be added to the tip	122	// list of <String, String> values to be added to the tip
125	// table	123	// table
126	Map<String, String> eventAddOns = _utilImp	124	Map<String, String> eventAddOns = _utilImp.getEventHoverToolTipInfo(threadEvent);
127	.getEventHoverToolTipInfo(threadEvent);	125	if (eventAddOns != null) {
128	for (Iterator<String> iter = eventAddOns.keySet()	126	for (Iterator<String> iter = eventAddOns.keySet().iterator(); iter.hasNext();) {
129	.iterator(); iter.hasNext();) {	127	String message = (String) iter.next();
130	String message = (String) iter.next();	128	addItem(message, eventAddOns.get(message));
131	addItem(message, eventAddOns.get(message));	129	}
132	}	130	}
133		131
134	long eventStartTime = -1;	132	long eventStartTime = -1;

Lines 26-31 Link Here

(-)plugin.xml (-1 / +8 lines)
26	name="%events.view.name"	26	name="%events.view.name"
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	icon="icons/eview16/timechart_view.gif"
		33	id="org.eclipse.linuxtools.tmf.ui.views.timechart"
		34	name="%timechart.view.name"
		35	restorable="true">
		36	</view>
29	</extension>	37	</extension>
30	<extension	38	<extension
31	point="org.eclipse.ui.editors">	39	point="org.eclipse.ui.editors">
Lines 406-412 Link Here
406	<extension	414	<extension
407	point="org.eclipse.core.contenttype.contentTypes">	415	point="org.eclipse.core.contenttype.contentTypes">
408	<content-type	416	<content-type
409	file-extensions="log"
410	id="org.eclipse.linuxtools.tmf.ui.content-type.trace"	417	id="org.eclipse.linuxtools.tmf.ui.content-type.trace"
411	name="%contenttype.trace"	418	name="%contenttype.trace"
412	priority="normal">	419	priority="normal">

Line 0 Link Here

(-)src/org/eclipse/linuxtools/tmf/ui/views/timechart/TimeChartAnalysisEntry.java (+249 lines)
		1	/*******************************************************************************
		2	* Copyright (c) 2010 Ericsson
		3	*
		4	* All rights reserved. This program and the accompanying materials are
		5	* made available under the terms of the Eclipse Public License v1.0 which
		6	* accompanies this distribution, and is available at
		7	* http://www.eclipse.org/legal/epl-v10.html
		8	*
		9	* Contributors:
		10	* Patrick Tasse - Initial API and implementation
		11	*******************************************************************************/
		12
		13	package org.eclipse.linuxtools.tmf.ui.views.timechart;
		14
		15	import java.util.Iterator;
		16	import java.util.NoSuchElementException;
		17	import java.util.Vector;
		18
		19	import org.eclipse.linuxtools.tmf.trace.ITmfTrace;
		20	import org.eclipse.linuxtools.tmf.ui.viewers.timeAnalysis.model.ITimeEvent;
		21	import org.eclipse.linuxtools.tmf.ui.viewers.timeAnalysis.model.ITmfTimeAnalysisEntry;
		22
		23	public class TimeChartAnalysisEntry implements ITmfTimeAnalysisEntry {
		24
		25	private ITmfTrace fTrace;
		26	private String fGroup;
		27	private Vector<TimeChartEvent> fTraceEvents;
		28	private int fPower = 0; // 2^fPower nanoseconds per vector position
		29	private long fReferenceTime = -1; // time corresponding to beginning of index 0
		30	private long fStartTime = -1; // time of first event
		31	private long fStopTime = -1; // time of last event
		32	private long fLastRank = -1; // rank of last processed trace event
		33
		34	TimeChartAnalysisEntry(ITmfTrace trace, int modelSize) {
		35	fTrace = trace;
		36	fTraceEvents = new Vector<TimeChartEvent>(modelSize);
		37	}
		38
		39	TimeChartAnalysisEntry(ITmfTrace trace, String group, int modelSize) {
		40	fTrace = trace;
		41	fTraceEvents = new Vector<TimeChartEvent>(modelSize);
		42	fGroup = group;
		43	}
		44
		45	@Override
		46	public String getGroupName() {
		47	return fGroup;
		48	}
		49
		50	@Override
		51	public int getId() {
		52	// TODO Auto-generated method stub
		53	return 0;
		54	}
		55
		56	@Override
		57	public String getName() {
		58	return fTrace.getName();
		59	}
		60
		61	@Override
		62	public long getStartTime() {
		63	return fStartTime;
		64	}
65
66	@Override
67	public long getStopTime() {
68	return fStopTime;
69	}
70
71	@Override
72	@Deprecated public <T extends ITimeEvent> Vector<T> getTraceEvents() {
73	return null;
74	}
75
76	@Override
77	public Iterator<ITimeEvent> getTraceEventsIterator() {
78	return new EntryIterator(0, Long.MAX_VALUE, 0);
79	}
80
81	@Override
82	public Iterator<ITimeEvent> getTraceEventsIterator(long startTime, long stopTime, long maxDuration) {
83	return new EntryIterator(startTime, stopTime, maxDuration);
84	}
85
86	private class EntryIterator implements Iterator<ITimeEvent> {
87	private final long fIteratorStartTime;
88	private final long fIteratorStopTime;
89	private final long fIteratorMaxDuration;
90	private long lastTime = -1;
91	private TimeChartEvent next = null;
92	private Iterator<ITimeEvent> nestedIterator = null;
93
94	public EntryIterator(long startTime, long stopTime, long maxDuration) {
95	fIteratorStartTime = startTime;
96	fIteratorStopTime = stopTime;
97	fIteratorMaxDuration = maxDuration;
98	}
99
100	@Override
101	public boolean hasNext() {
102	synchronized (fTraceEvents) {
103	if (next != null) return true;
104	if (nestedIterator != null) {
105	if (nestedIterator.hasNext()) {
106	return true;
107	} else {
108	nestedIterator = null;
109	}
110	}
111	long time = (lastTime == -1) ? fStartTime : lastTime;
112	int index = (fReferenceTime == -1) ? 0 : (int) ((time - fReferenceTime) >> fPower);
113	while (index < fTraceEvents.size()) {
114	TimeChartEvent event = fTraceEvents.get(index++);
115	if (event != null && (lastTime == -1 \|\| event.getTime() > time)) {
116	if (event.getTime() + event.getDuration() >= fIteratorStartTime && event.getTime() <= fIteratorStopTime) {
117	if (event.getItemizedEntry() == null \|\| event.getDuration() <= fIteratorMaxDuration) {
118	lastTime = event.getTime() + event.getDuration();
119	next = event;
120	return true;
121	} else {
122	nestedIterator = event.getItemizedEntry().getTraceEventsIterator(fIteratorStartTime, fIteratorStopTime, fIteratorMaxDuration);
123	return nestedIterator.hasNext();
124	}
125	}
126	}
127	}
128	return false;
129	}
130	}
131
132	@Override
133	public TimeChartEvent next() {
134	synchronized (fTraceEvents) {
135	if (nestedIterator != null) {
136	TimeChartEvent event = (TimeChartEvent) nestedIterator.next();
137	lastTime = event.getTime() + event.getDuration();
138	return event;
139	}
140	if (hasNext()) {
141	TimeChartEvent event = next;
142	next = null;
143	return event;
144	}
145	throw new NoSuchElementException();
146	}
147	}
148
149	@Override
150	public void remove() {
151	throw new UnsupportedOperationException();
152	}
153
154	}
155
156	@Override
157	public void addTraceEvent(ITimeEvent timeEvent) {
158	long time = timeEvent.getTime();
159	synchronized (fTraceEvents) {
160	long index = (fReferenceTime == -1) ? 0 : (time - fReferenceTime) >> fPower;
161	if (index < 0) {
162	if (fTraceEvents.capacity() - fTraceEvents.size() < -index) {
163	int powershift = (-index + fTraceEvents.size() <= 2 * fTraceEvents.capacity()) ? 1 :
164	(int) Math.ceil(Math.log((double) (-index + fTraceEvents.size()) / fTraceEvents.capacity()) / Math.log(2));
165	merge(powershift);
166	index = (int) ((time - fReferenceTime) >> fPower);
167	}
168	shift((int) -index);
169	index = 0;
170	fTraceEvents.set(0, (TimeChartEvent) timeEvent);
171	} else if (index < fTraceEvents.capacity()) {
172	if (index >= fTraceEvents.size()) {
173	fTraceEvents.setSize((int) index + 1);
174	}
175	} else {
176	int powershift = (index < 2 * fTraceEvents.capacity()) ? 1 :
177	(int) Math.ceil(Math.log((double) (index + 1) / fTraceEvents.capacity()) / Math.log(2));
178	merge(powershift);
179	index = (int) ((time - fReferenceTime) >> fPower);
180	fTraceEvents.setSize((int) index + 1);
181	}
182	TimeChartEvent event = (TimeChartEvent) fTraceEvents.get((int) index);
183	if (event == null) {
184	fTraceEvents.set((int) index, (TimeChartEvent) timeEvent);
185	} else {
186	if (event.getItemizedEntry() == null) {
187	event.merge((TimeChartEvent) timeEvent);
188	} else {
189	event.mergeDecorations((TimeChartEvent) timeEvent);
190	event.getItemizedEntry().addTraceEvent(timeEvent);
191	}
192	}
193	if (fReferenceTime == -1 \|\| time < fReferenceTime) {
194	fReferenceTime = (time >> fPower) << fPower;
195	}
196	if (fStartTime == -1 \|\| time < fStartTime) {
197	fStartTime = time;
198	}
199	if (fStopTime == -1 \|\| time > fStopTime) {
200	fStopTime = time;
201	}
202	}
203	}
204
205	private void merge(int powershift) {
206	fPower += powershift;
207	fReferenceTime = (fReferenceTime >> fPower) << fPower;
208	int index = 0;
209	for (int i = 0; i < fTraceEvents.size(); i++) {
210	TimeChartEvent event = fTraceEvents.get(i);
211	if (event != null) {
212	index = (int) ((event.getTime() - fReferenceTime) >> fPower);
213	TimeChartEvent mergedEvent = (TimeChartEvent) fTraceEvents.get(index);
214	if (mergedEvent == null) {
215	fTraceEvents.set(index, event);
216	} else {
217	mergedEvent.merge(event);
218	}
219	if (i != index) {
220	fTraceEvents.set(i, null);
221	}
222	}
223	}
224	fTraceEvents.setSize(index + 1);
225	}
226
227	private void shift(int indexshift) {
228	int oldSize = fTraceEvents.size();
229	fTraceEvents.setSize(oldSize + indexshift);
230	for (int i = oldSize - 1; i >= 0; i--) {
231	fTraceEvents.set(i + indexshift, fTraceEvents.get(i));
232	}
233	for (int i = 0; i < indexshift; i++) {
234	fTraceEvents.set(i, null);
235	}
236	}
237
238	public ITmfTrace getTrace() {
239	return fTrace;
240	}
241
242	public void setLastRank(long rank) {
243	fLastRank = rank;
244	}
245
246	public long getLastRank() {
247	return fLastRank;
248	}
249	}

Lines 35-44 Link Here

(-)widgetStubs/org/eclipse/linuxtools/tmf/ui/widgets/timeAnalysis/test/stub/views/TsfTraceAnalysisView.java (-2 / +3 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 596-602 Link Here
596	viewer.getControl().setFocus();	596	viewer.getControl().setFocus();
597	}	597	}
598		598
599	@Override	599	@SuppressWarnings("deprecation")
		600	@Override
600	public void tsfTmProcessSelEvent(TmfTimeSelectionEvent event) {	601	public void tsfTmProcessSelEvent(TmfTimeSelectionEvent event) {
601	Object source = event.getSource();	602	Object source = event.getSource();
602	if (source == null \|\| !(source instanceof ITimeAnalysisViewer)) {	603	if (source == null \|\| !(source instanceof ITimeAnalysisViewer)) {