Attachment 189664 Details for Bug 325016 – Proposed patch in org.eclipse.linuxtools.tmf.ui package

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

[patch] Proposed patch in org.eclipse.linuxtools.tmf.ui package

org.eclipse.linuxtools.tmf.ui-325016.patch (text/plain), 92.08 KB, created by Patrick Tasse

on 2011-02-23 18:28:55 EST

(hide)

Description:

Filename:

MIME Type:

Creator: Patrick Tasse

Created: 2011-02-23 18:28:55 EST

Size: 92.08 KB

patch

obsolete

>### Eclipse Workspace Patch 1.0
>#P org.eclipse.linuxtools.tmf.ui
>Index: plugin.properties
>===================================================================
>--- plugin.properties	(revision 27125)
>+++ plugin.properties	(working copy)
>@@ -6,6 +6,7 @@
> views.category.name = TMF
> project.view.name = Projects
> events.view.name = Events
>+timechart.view.name = Time Chart
> events.editor.name = Events
> 
> wizard.category.name = TMF
>Index: src/org/eclipse/linuxtools/tmf/ui/viewers/timeAnalysis/TmfTimeAnalysisProvider.java
>===================================================================
>--- src/org/eclipse/linuxtools/tmf/ui/viewers/timeAnalysis/TmfTimeAnalysisProvider.java	(revision 27125)
>+++ src/org/eclipse/linuxtools/tmf/ui/viewers/timeAnalysis/TmfTimeAnalysisProvider.java	(working copy)
>@@ -12,12 +12,10 @@
> 
> 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;
>@@ -274,6 +272,8 @@
> 		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) {
>@@ -281,6 +281,7 @@
> 				name += " (" + getEventName(event, false, true) + ")"; //$NON-NLS-1$ //$NON-NLS-2$
> 			}
> 		}
>+		*/
> 		return name;
> 	}
> 
>Index: src/org/eclipse/linuxtools/tmf/ui/viewers/timeAnalysis/TmfTimeAnalysisViewer.java
>===================================================================
>--- src/org/eclipse/linuxtools/tmf/ui/viewers/timeAnalysis/TmfTimeAnalysisViewer.java	(revision 27125)
>+++ src/org/eclipse/linuxtools/tmf/ui/viewers/timeAnalysis/TmfTimeAnalysisViewer.java	(working copy)
>@@ -17,7 +17,6 @@
> 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;
>@@ -110,7 +109,7 @@
> 	// called from the display order in the API
> 	public void modelUpdate(ITmfTimeAnalysisEntry[] traces) {
> 		if (null != _stateCtrl) {
>-			loadOptions();
>+			//loadOptions();
> 			updateInternalData(traces);
> 			_stateCtrl.redraw();
> 			_timeScaleCtrl.redraw();
>@@ -121,7 +120,7 @@
> 	public void modelUpdate(ITmfTimeAnalysisEntry[] traces, long start,
> 			long end, boolean updateTimeBounds) {
> 		if (null != _stateCtrl) {
>-			loadOptions();
>+			//loadOptions();
> 			updateInternalData(traces, start, end);
> 			if (updateTimeBounds) {
> 				_timeRangeFixed = true;
>@@ -230,7 +229,7 @@
> 	void setTimeRange(Object traces[]) {
> 		_endTime = 0;
> 		_beginTime = -1;
>-		ITimeEvent event;
>+//		ITimeEvent event;
> 		for (int i = 0; i < traces.length; i++) {
> 			ITmfTimeAnalysisEntry entry = (ITmfTimeAnalysisEntry) traces[i];
> 			if (entry.getStopTime() >= entry.getStartTime() && entry.getStopTime() > 0) {
>@@ -241,6 +240,8 @@
> 			        _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) {
>@@ -254,6 +255,7 @@
> 					_endTime = eventEndTime;
> 				}
> 			}
>+			*/
> 		}
> 
> 		if (_beginTime < 0)
>@@ -475,6 +477,8 @@
> 			_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;
>@@ -498,6 +502,9 @@
> 		_stateCtrl.adjustScrolls();
> 		_stateCtrl.redraw();
> 		_timeScaleCtrl.redraw();
>+		if (time0 != _time0 || time1 != _time1) {
>+			notifyStartFinishTimeSelectionListeners(_time0, _time1);
>+		}
> 	}
> 
> 	@Override
>@@ -819,6 +826,13 @@
> 		}
> 	}
> 
>+    @Override
>+    public void setMinimumItemWidth(int width) {
>+        if (_stateCtrl != null) {
>+            _stateCtrl.setMinimumItemWidth(width);
>+        }
>+    }
>+    
> 	@Override
> 	public boolean isVisibleVerticalScroll() {
> 		if (_stateCtrl != null) {
>Index: src/org/eclipse/linuxtools/tmf/ui/viewers/timeAnalysis/model/ITmfTimeAnalysisEntry.java
>===================================================================
>--- src/org/eclipse/linuxtools/tmf/ui/viewers/timeAnalysis/model/ITmfTimeAnalysisEntry.java	(revision 27125)
>+++ src/org/eclipse/linuxtools/tmf/ui/viewers/timeAnalysis/model/ITmfTimeAnalysisEntry.java	(working copy)
>@@ -12,6 +12,7 @@
> 
> package org.eclipse.linuxtools.tmf.ui.viewers.timeAnalysis.model;
> 
>+import java.util.Iterator;
> import java.util.Vector;
> 
> public interface ITmfTimeAnalysisEntry {
>@@ -26,5 +27,27 @@
> 
> 	public long getStopTime();
> 
>-	public <T extends ITimeEvent>  Vector<T> getTraceEvents();
>+    /**
>+     * 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);
> }
>Index: src/org/eclipse/linuxtools/tmf/ui/viewers/timeAnalysis/ITimeAnalysisViewer.java
>===================================================================
>--- src/org/eclipse/linuxtools/tmf/ui/viewers/timeAnalysis/ITimeAnalysisViewer.java	(revision 27125)
>+++ src/org/eclipse/linuxtools/tmf/ui/viewers/timeAnalysis/ITimeAnalysisViewer.java	(working copy)
>@@ -126,6 +126,8 @@
> 
> 	public void setItemHeight(int rowHeight);
> 
>+    public void setMinimumItemWidth(int width);
>+
> 	public void resizeControls();
> 
> 	public void setSelectedTrace(ITmfTimeAnalysisEntry trace);
>Index: src/org/eclipse/linuxtools/tmf/ui/viewers/timeAnalysis/widgets/TmfTimeStatesCtrl.java
>===================================================================
>--- src/org/eclipse/linuxtools/tmf/ui/viewers/timeAnalysis/widgets/TmfTimeStatesCtrl.java	(revision 27125)
>+++ src/org/eclipse/linuxtools/tmf/ui/viewers/timeAnalysis/widgets/TmfTimeStatesCtrl.java	(working copy)
>@@ -64,6 +64,10 @@
>  */
> public class TmfTimeStatesCtrl extends TraceCtrl implements FocusListener, KeyListener, MouseMoveListener, MouseListener, MouseWheelListener, ControlListener, SelectionListener, MouseTrackListener, TraverseListener, ISelectionProvider {
> 
>+    private static final int DRAG_NONE = 0;
>+    private static final int DRAG_TRACE_ITEM = 1;
>+    private static final int DRAG_GROUP_ITEM = 2;
>+    private static final int DRAG_SPLIT_LINE = 3;
>     public static final boolean DEFAULT_DRAW_THREAD_JOIN = true;
>     public static final boolean DEFAULT_DRAW_THREAD_WAIT = true;
>     public static final boolean DEFAULT_DRAW_THREAD_RELEASE = true;
>@@ -78,8 +82,9 @@
>     private boolean _mouseHover = false;
>     private int _itemHeightDefault = 19;
>     private int _itemHeight = _itemHeightDefault;
>+    private int _minimumItemWidth = 0;
>     private int _topItem = 0;
>-    private int _dragState = 0;
>+    private int _dragState = DRAG_NONE;
>     private int _hitIdx = 0;
>     private int _dragX0 = 0;
>     private int _dragX = 0;
>@@ -132,14 +137,6 @@
>         if (scrollHor != null) {
>             scrollHor.addSelectionListener(this);
>         }
>-        mouseScrollFilterListener = new Listener() {
>-            // This filter is used to prevent scrolling of the view when the
>-            // mouse wheel is used to zoom
>-            @Override
>-            public void handleEvent(Event event) {
>-                event.doit = false;
>-            }
>-        };
> 
>         _dragCursor3 = new Cursor(super.getDisplay(), SWT.CURSOR_SIZEWE);
>         _WaitCursor = new Cursor(super.getDisplay(), SWT.CURSOR_WAIT);
>@@ -451,7 +448,7 @@
>         if (zoomIn) {
>             newInterval = Math.max(Math.round((double) interval * 0.8), _timeProvider.getMinTimeInterval());
>         } else {
>-            newInterval = Math.round((double) interval * 1.25);
>+            newInterval = (long) Math.ceil((double) interval * 1.25);
>         }
>         long center = time0 + Math.round(((double) (xPos - nameSpace) / timeSpace * interval));
>         long newTime0 = center - Math.round((double) newInterval * (center - time0) / interval);
>@@ -621,7 +618,7 @@
>         return idx >= 0 ? (Item) _data._items[idx] : null;
>     }
> 
>-    long hitTimeTest(int x, int y) {
>+    long hitTimeTest(int x) {
>         if (null == _timeProvider)
>             return -1;
>         long hitTime = -1;
>@@ -644,25 +641,32 @@
>     }
> 
>     void selectItem(int idx, boolean addSelection) {
>+        boolean changed = false;
>         if (addSelection) {
>             if (idx >= 0 && idx < _data._items.length) {
>                 Item item = (Item) _data._items[idx];
>+                changed = (item._selected == false);
>                 item._selected = true;
>             }
>         } else {
>             for (int i = 0; i < _data._items.length; i++) {
>                 Item item = (Item) _data._items[i];
>+                if (i == idx && item._selected == false) {
>+                    changed = true;
>+                }
>                 item._selected = i == idx;
>             }
>         }
>-        boolean changed = ensureVisibleItem(idx, true);
>-        if (!changed)
>+        changed |= ensureVisibleItem(idx, true);
>+        if (changed)
>             redraw();
>     }
> 
>     public void selectItem(ITmfTimeAnalysisEntry trace, boolean addSelection) {
>         Integer idx = _data.findTraceItemIndex(trace);
>-        selectItem(idx, addSelection);
>+        if (idx != null) {
>+            selectItem(idx, addSelection);
>+        }
>     }
> 
>     public int countPerPage() {
>@@ -946,11 +950,17 @@
>         if (drawTracesInteraction)
>             drawTraceInteractions(bound, e.gc);
> 
>+        // draw empty name space background
>+        if (_itemHeight * items.length < bound.height) {
>+            gc.setBackground(_colors.getBkColor(false, false, true));
>+            drawBackground(gc, bound.x, _itemHeight * items.length, nameWidth, bound.height - _itemHeight * items.length);
>+        }
>+
>         // draw drag line, no line if name space is 0.
>-        if (3 == _dragState) {
>+        if (DRAG_SPLIT_LINE == _dragState) {
>             gc.setForeground(_colors.getColor(TraceColorScheme.BLACK));
>             gc.drawLine(bound.x + nameWidth, bound.y, bound.x + nameWidth, bound.y + bound.height - 1);
>-        } else if (0 == _dragState && _mouseHover && _timeProvider.getNameSpace() > 0) {
>+        } else if (DRAG_NONE == _dragState && _mouseHover && _timeProvider.getNameSpace() > 0) {
>             gc.setForeground(_colors.getColor(TraceColorScheme.RED));
>             gc.drawLine(bound.x + nameWidth, bound.y, bound.x + nameWidth, bound.y + bound.height - 1);
>         }
>@@ -1066,12 +1076,10 @@
>             ITmfTimeAnalysisEntry trace = ((TraceItem) item)._trace;
> 
>             int x0 = rect.x;
>-            List<TimeEvent> list = trace.getTraceEvents();
>-            // Iterator it = list.iterator();
>-            int count = list.size();
>+            Iterator<ITimeEvent> iterator = trace.getTraceEventsIterator();
>             ITimeEvent lastEvent = null;
>-            if (count > 0) {
>-                ITimeEvent currEvent = list.get(0);
>+            if (iterator.hasNext()) {
>+                ITimeEvent currEvent = iterator.next();
>                 ITimeEvent nextEvent = null;
>                 long currEventTime = currEvent.getTime();
>                 long nextEventTime = currEventTime;
>@@ -1083,14 +1091,14 @@
>                 // reduce rect
>                 _rect1.y += 3;
>                 _rect1.height -= 6;
>-                fillSpace(rect, gc, selected, _rect1.x, x0, xEnd);
>+                fillSpace(rect, gc, selected);
> 
>                 // draw event states
>                 while (x0 <= xEnd && null != currEvent) {
>                     boolean stopped = false;// currEvent instanceof
>                     // TsfTmTraceDeadEvent;
>-                    if (idx < count) {
>-                        nextEvent = list.get(idx);
>+                    if (iterator.hasNext()) {
>+                        nextEvent = iterator.next();
>                         nextEventTime = nextEvent.getTime();
>                         idx++;
>                     } else if (stopped) {
>@@ -1133,22 +1141,6 @@
>                 gc.drawLine(_rect1.x, midy, _rect1.x + _rect1.width, midy);
>                 gc.setLineWidth(lw);
>             }
>-
>-            // draw focus ares
>-            Utils.init(_rect1, rect);
>-            gc.setForeground(_colors.getBkColor(selected, _isInFocus, false));
>-            int y = _rect1.y;
>-            gc.drawLine(_rect1.x, y, _rect1.x + _rect1.width, y);
>-            y++;
>-            gc.drawLine(_rect1.x, y, _rect1.x + _rect1.width, y);
>-            y++;
>-            gc.drawLine(_rect1.x, y, _rect1.x + _rect1.width, y);
>-            y = _rect1.y + _rect1.height - 1;
>-            gc.drawLine(_rect1.x, y, _rect1.x + _rect1.width, y);
>-            y--;
>-            gc.drawLine(_rect1.x, y, _rect1.x + _rect1.width, y);
>-            y--;
>-            gc.drawLine(_rect1.x, y, _rect1.x + _rect1.width, y);
>         }
> 
>         // draw selected time
>@@ -1205,13 +1197,11 @@
>             ITmfTimeAnalysisEntry trace = ((TraceItem) item)._trace;
> 
>             double x0 = rect.x;
>-            List<TimeEvent> list = trace.getTraceEvents();
>-            // Iterator it = list.iterator();
>-            int count = list.size();
>+            Iterator<ITimeEvent> iterator = trace.getTraceEventsIterator();
>             ITimeEvent lastEvent = null;
>             // Trace.debug("count is: " + count);
>-            if (count > 0) {
>-                ITimeEvent currEvent = list.get(0);
>+            if (iterator.hasNext()) {
>+                ITimeEvent currEvent = iterator.next();
>                 ITimeEvent nextEvent = null;
>                 long currEventTime = currEvent.getTime();
>                 long nextEventTime = currEventTime;
>@@ -1222,20 +1212,20 @@
>                 double xEnd = rect.x + (double) ((time1 - time0) * pixelsPerNanoSec);
>                 double x1 = -1;
>                 int idx = 1;
>-                double xNext = 0;
>+                //double xNext = 0;
> 
>                 // Drawing rectangle is smaller than reserved space
>                 _rect1.y += 3;
>                 _rect1.height -= 6;
> 
>                 // Clean up to empty line to draw on top
>-                fillSpace(rect, gc, selected, _rect1.x, xEnd, xEnd);
>+                fillSpace(rect, gc, selected);
>                 // draw event states
>                 while (x0 <= xEnd && null != currEvent) {
>                     boolean stopped = false;// currEvent instanceof
>                     // TsfTmTraceDeadEvent;
>-                    if (idx < count) {
>-                        nextEvent = list.get(idx);
>+                    if (iterator.hasNext()) {
>+                        nextEvent = iterator.next();
>                         nextEventTime = nextEvent.getTime();
>                         idx++;
>                     } else if (stopped) {
>@@ -1265,10 +1255,10 @@
>                         // with space until next event
>                         _rect1.x += _rect1.width;
>                         x0 = x1;
>-                        xNext = rect.x + (double) ((nextEventTime - time0) * pixelsPerNanoSec);
>+                        //xNext = rect.x + (double) ((nextEventTime - time0) * pixelsPerNanoSec);
>                     }
>                     // Fill space till next event
>-                    fillSpace(rect, gc, selected, x0, xNext, xEnd);
>+                    fillSpace(rect, gc, selected);
> 
>                     lastEvent = currEvent;
>                     currEvent = nextEvent;
>@@ -1299,22 +1289,6 @@
>                 gc.drawLine(_rect1.x, midy, _rect1.x + _rect1.width, midy);
>                 gc.setLineWidth(lw);
>             }
>-
>-            // draw focus area
>-            Utils.init(_rect1, rect);
>-            gc.setForeground(_colors.getBkColor(selected, _isInFocus, false));
>-            int y = _rect1.y;
>-            gc.drawLine(_rect1.x, y, _rect1.x + _rect1.width, y);
>-            y++;
>-            gc.drawLine(_rect1.x, y, _rect1.x + _rect1.width, y);
>-            y++;
>-            gc.drawLine(_rect1.x, y, _rect1.x + _rect1.width, y);
>-            y = _rect1.y + _rect1.height - 1;
>-            gc.drawLine(_rect1.x, y, _rect1.x + _rect1.width, y);
>-            y--;
>-            gc.drawLine(_rect1.x, y, _rect1.x + _rect1.width, y);
>-            y--;
>-            gc.drawLine(_rect1.x, y, _rect1.x + _rect1.width, y);
>         }
> 
>         // draw selected time
>@@ -1370,10 +1344,8 @@
>             ITmfTimeAnalysisEntry trace = ((TraceItem) item)._trace;
> 
>             double x0 = rect.x;
>-            @SuppressWarnings("unchecked")
>-            List<TimeEvent> list = (List<TimeEvent>) trace.getTraceEvents().clone();
>-            // Iterator it = list.iterator();
>-            int count = list.size();
>+            long maxDuration = (_timeProvider.getTimeSpace() == 0) ? Long.MAX_VALUE : 1 * (_timeProvider.getTime1() - _timeProvider.getTime0()) / _timeProvider.getTimeSpace();
>+            Iterator<ITimeEvent> iterator = trace.getTraceEventsIterator(_timeProvider.getTime0(), _timeProvider.getTime1(), maxDuration);
>             // ITimeEvent lastEvent = null;
>             // if (Trace.isDEBUG()) {
>             // Trace.debug("\n\t\t\tTrace: " + trace.getName()
>@@ -1386,9 +1358,9 @@
> 
>             // Clean up to empty line to draw on top
>             int xEnd = rect.x + rect.width;
>-            fillSpace(rect, gc, selected, _rect1.x, xEnd, xEnd);
>-            if (count > 0) {
>-                ITimeEvent currEvent = list.get(0);
>+            fillSpace(rect, gc, selected);
>+            if (iterator.hasNext()) {
>+                ITimeEvent currEvent = iterator.next();
>                 ITimeEvent nextEvent = null;
>                 long currEventTime = currEvent.getTime();
>                 long currEventDuration = currEvent.getDuration();
>@@ -1408,8 +1380,8 @@
>                     // refresh current event duration as the loop moves
>                     currEventDuration = currEvent.getDuration();
>                     // TsfTmTraceDeadEvent;
>-                    if (idx < count) {
>-                        nextEvent = list.get(idx);
>+                    if (iterator.hasNext()) {
>+                        nextEvent = iterator.next();
>                         nextEventTime = nextEvent.getTime();
>                         idx++;
>                     } else if (stopped) {
>@@ -1448,11 +1420,11 @@
>                     if (x1 >= rect.x && x0 <= xEnd) {
>                         if (currEventDuration != 0) {
>                             x0 = (double) (x0 >= rect.x ? x0 : rect.x);
>-                            _rect1.width = (int) ((x1 <= xEnd ? x1 : xEnd) - x0);
>+                            _rect1.width = (int) Math.ceil(x1 <= xEnd ? x1 : xEnd) - (int) x0;
>                         } else {
>-                            _rect1.width = 2; // make punctual events 2 pixels
>-                                              // wide
>+                            _rect1.width = 1;
>                         }
>+                        _rect1.width = Math.max(_minimumItemWidth, _rect1.width);
>                         _rect1.x = (int) x0;
>                         boolean timeSelected = currEventTime <= selectedTime && selectedTime < nextEventTime;
>                         utilImpl.drawState(_colors, currEvent, _rect1, gc, selected, false, timeSelected);
>@@ -1480,22 +1452,6 @@
>                     // + K + " = " + x0);
>                 }
>             }
>-
>-            // draw focus area
>-            Utils.init(_rect1, rect);
>-            gc.setForeground(_colors.getBkColor(selected, _isInFocus, false));
>-            int y = _rect1.y;
>-            gc.drawLine(_rect1.x, y, _rect1.x + _rect1.width, y);
>-            y++;
>-            gc.drawLine(_rect1.x, y, _rect1.x + _rect1.width, y);
>-            y++;
>-            gc.drawLine(_rect1.x, y, _rect1.x + _rect1.width, y);
>-            y = _rect1.y + _rect1.height - 1;
>-            gc.drawLine(_rect1.x, y, _rect1.x + _rect1.width, y);
>-            y--;
>-            gc.drawLine(_rect1.x, y, _rect1.x + _rect1.width, y);
>-            y--;
>-            gc.drawLine(_rect1.x, y, _rect1.x + _rect1.width, y);
>         }
> 
>         // draw selected time
>@@ -1509,27 +1465,13 @@
>         }
>     }
> 
>-    private void fillSpace(Rectangle rect, GC gc, boolean selected, double x0, double x1, double xEnd) {
>-        // fill space before first event
>-        if (x0 >= rect.x && x0 < xEnd) {
>-            // _rect1.width = (int) ((x1 <= xEnd ? x1 : xEnd) - x0);
>-            // Trace.debug("Drawing Space: " + _rect1.x + "," + _rect1.y + ","
>-            // + _rect1.height + ", " + _rect1.width + "--> "
>-            // + ((int) _rect1.x + (int) _rect1.width));
>-
>-            // if (_rect1.width < 0) {
>-            // Trace.debug("Incorrect width:" + _rect1.width);
>-            // }
>-            gc.setBackground(_colors.getBkColor(selected, _isInFocus, false));
>-            gc.fillRectangle(_rect1);
>-            // draw middle line
>-            gc.setForeground(_colors.getColor(TraceColorScheme.MID_LINE));
>-            int midy = _rect1.y + _rect1.height / 2;
>-            gc.drawLine(_rect1.x, midy, _rect1.x + _rect1.width, midy);
>-        } else {
>-            // Trace.debug("No space added since, x0 is out of range " + x0
>-            // + " rect.x: " + rect.x + " xEnd: " + xEnd);
>-        }
>+    private void fillSpace(Rectangle rect, GC gc, boolean selected) {
>+        gc.setBackground(_colors.getBkColor(selected, _isInFocus, false));
>+        gc.fillRectangle(rect);
>+        // draw middle line
>+        gc.setForeground(_colors.getColor(TraceColorScheme.MID_LINE));
>+        int midy = rect.y + rect.height / 2;
>+        gc.drawLine(rect.x, midy, rect.x + rect.width, midy);
>     }
> 
>     @Override
>@@ -1601,18 +1543,31 @@
>     public void focusGained(FocusEvent e) {
>         _isInFocus = true;
>         redraw();
>-        getDisplay().addFilter(SWT.MouseWheel, mouseScrollFilterListener);
>+        if (mouseScrollFilterListener == null) {
>+            mouseScrollFilterListener = new Listener() {
>+                // This filter is used to prevent scrolling of the view when the
>+                // mouse wheel is used to zoom
>+                @Override
>+                public void handleEvent(Event event) {
>+                    event.doit = false;
>+                }
>+            };
>+            getDisplay().addFilter(SWT.MouseWheel, mouseScrollFilterListener);
>+        }
>     }
> 
>     @Override
>     public void focusLost(FocusEvent e) {
>         _isInFocus = false;
>-        if (0 != _dragState) {
>+        if (DRAG_NONE != _dragState) {
>             setCapture(false);
>-            _dragState = 0;
>+            _dragState = DRAG_NONE;
>         }
>         redraw();
>-        getDisplay().removeFilter(SWT.MouseWheel, mouseScrollFilterListener);
>+        if (mouseScrollFilterListener != null) {
>+            getDisplay().removeFilter(SWT.MouseWheel, mouseScrollFilterListener);
>+            mouseScrollFilterListener = null;
>+        }
>     }
> 
>     public boolean isInFocus() {
>@@ -1624,7 +1579,7 @@
>         if (null == _timeProvider)
>             return;
>         Point size = getCtrlSize();
>-        if (1 == _dragState) {
>+        if (DRAG_TRACE_ITEM == _dragState) {
>             int nameWidth = _timeProvider.getNameSpace();
>             int x = e.x - nameWidth;
>             if (x > 0 && size.x > nameWidth && _dragX != x) {
>@@ -1642,10 +1597,10 @@
>                 }
>                 _timeProvider.setStartFinishTime(time0, time1);
>             }
>-        } else if (3 == _dragState) {
>+        } else if (DRAG_SPLIT_LINE == _dragState) {
>             _dragX = e.x;
>             _timeProvider.setNameSpace(_hitIdx + _dragX - _dragX0);
>-        } else if (0 == _dragState) {
>+        } else if (DRAG_NONE == _dragState) {
>             boolean mouseHover = hitSplitTest(e.x, e.y) > 0;
>             if (_mouseHover != mouseHover)
>                 redraw();
>@@ -1734,7 +1689,7 @@
>             if (namewidth != 0) {
>                 idx = hitSplitTest(e.x, e.y);
>                 if (idx > 0) {
>-                    _dragState = 3;
>+                    _dragState = DRAG_SPLIT_LINE;
>                     _dragX = _dragX0 = e.x;
>                     _hitIdx = _timeProvider.getNameSpace();
>                     ;
>@@ -1748,42 +1703,51 @@
>             idx = hitTest(e.x, e.y);
>             if (idx >= 0) {
>                 if (_data._items[idx] instanceof TraceItem) {
>-                    long hitTime = hitTimeTest(e.x, e.y);
>+                    long hitTime = hitTimeTest(e.x);
>                     if (hitTime >= 0) {
>-                        _timeProvider.setSelectedTimeInt(hitTime, false);
>+                        // _timeProvider.setSelectedTimeInt(hitTime, false);
>                         setCapture(true);
>-                        _dragState = 1;
>+                        _dragState = DRAG_TRACE_ITEM;
>                         _dragX = _dragX0 = e.x - _timeProvider.getNameSpace();
>+                        _hitIdx = idx;
>                         _time0bak = _timeProvider.getTime0();
>                         _time1bak = _timeProvider.getTime1();
>+                        return;
>                     }
>                 } else if (_data._items[idx] instanceof GroupItem) {
>-                    _hitIdx = idx;
>-                    _dragState = 2;
>+                    _dragX0 = e.x;
>+                    _dragState = DRAG_GROUP_ITEM;
>                 }
>                 selectItem(idx, false);
>                 fireSelectionChanged();
>             } else {
>                 selectItem(idx, false); // clear selection
>+                redraw();
>             }
>         }
>     }
> 
>     @Override
>     public void mouseUp(MouseEvent e) {
>-        if (0 != _dragState) {
>+        if (DRAG_NONE != _dragState) {
>             setCapture(false);
>-            if (1 == _dragState) {
>+            if (DRAG_TRACE_ITEM == _dragState) {
>                 // Notify time provider to check the need for listener
>                 // notification
>                 _timeProvider.notifyStartFinishTime();
>-            } else if (2 == _dragState) {
>-                if (hitTest(e.x, e.y) == _hitIdx)
>+                if (_dragX == _dragX0) { // click without drag
>+                    long time = hitTimeTest(e.x);
>+                    _timeProvider.setSelectedTimeInt(time, false);
>+                    selectItem(_hitIdx, false);
>+                    fireSelectionChanged();
>+                }
>+            } else if (DRAG_GROUP_ITEM == _dragState) {
>+                if (e.x == _dragX0) // click without drag
>                     toggle(_hitIdx);
>-            } else if (3 == _dragState) {
>+            } else if (DRAG_SPLIT_LINE == _dragState) {
>                 redraw();
>             }
>-            _dragState = 0;
>+            _dragState = DRAG_NONE;
>         }
>     }
> 
>@@ -1849,7 +1813,7 @@
> 
>     @Override
>     public void mouseScrolled(MouseEvent e) {
>-        if (!_isInFocus)
>+        if (!_isInFocus || _dragState != DRAG_NONE)
>             return;
>         if (e.count > 0) {
>             zoom(true);
>@@ -1895,6 +1859,10 @@
>         this._itemHeight = rowHeight;
>     }
> 
>+    public void setMinimumItemWidth(int width) {
>+        this._minimumItemWidth = width;
>+    }
>+
>     public Vector<ITmfTimeAnalysisEntry> getFilteredOut() {
>         return _data.getFilteredOut();
>     }
>@@ -2033,21 +2001,17 @@
>         if (trace == null)
>             return null;
> 
>-        int traceId = trace.getId();
>-
>-        Integer idx = null;
>         for (int i = 0; i < _items.length; i++) {
>-            idx = i;
>             Object item = _items[i];
>             if (item instanceof TraceItem) {
>                 TraceItem ti = (TraceItem) item;
>-                if (ti._trace.getId() == traceId) {
>-                    break;
>+                if (ti._trace == trace) {
>+                    return i;
>                 }
>             }
>         }
> 
>-        return idx;
>+        return null;
>     }
> 
>     public void updateItems() {
>@@ -2109,7 +2073,7 @@
>      */
>     public void refreshPartial(ITmfTimeAnalysisEntry parent, TimeEvent childItem) {
>         // Find the Trace item within the current list
>-        TraceItem item = findTraceItem(parent);
>+//        TraceItem item = findTraceItem(parent);
> 
>         // This method is not used (yet) so this code can be commented out for
>         // now
>@@ -2142,6 +2106,8 @@
>         // item = findTraceItem(parent);
>         // }
> 
>+        /*
>+         * Check if this is still needed!
>         ITmfTimeAnalysisEntry localTraceItem = item._trace;
>         // Local trace found
>         Vector<TimeEvent> children = localTraceItem.getTraceEvents();
>@@ -2157,6 +2123,7 @@
>         }
>         // Add the new item
>         children.add(childItem);
>+        */
> 
>     }
> 
>Index: src/org/eclipse/linuxtools/tmf/ui/viewers/timeAnalysis/widgets/TimeScaleCtrl.java
>===================================================================
>--- src/org/eclipse/linuxtools/tmf/ui/viewers/timeAnalysis/widgets/TimeScaleCtrl.java	(revision 27125)
>+++ src/org/eclipse/linuxtools/tmf/ui/viewers/timeAnalysis/widgets/TimeScaleCtrl.java	(working copy)
>@@ -104,6 +104,9 @@
>                 unit = MIN_IN_NS;
>             } else if (minDelta > 20 * SEC_IN_NS) {
>                 unit = 30 * SEC_IN_NS;
>+            } else if (minDelta <= 1) {
>+                _timeDelta = 1;
>+                return;
>             }
>         }
>         double log = Math.log10((double) minDelta / unit);
>Index: src/org/eclipse/linuxtools/tmf/ui/viewers/timeAnalysis/widgets/Utils.java
>===================================================================
>--- src/org/eclipse/linuxtools/tmf/ui/viewers/timeAnalysis/widgets/Utils.java	(revision 27125)
>+++ src/org/eclipse/linuxtools/tmf/ui/viewers/timeAnalysis/widgets/Utils.java	(working copy)
>@@ -18,14 +18,11 @@
> 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;
>@@ -323,11 +320,12 @@
> 	static ITimeEvent getFirstEvent(ITmfTimeAnalysisEntry thread) {
> 		if (null == thread)
> 			return null;
>-		Vector<TimeEvent> list =   thread.getTraceEvents();
>-		ITimeEvent event = null;
>-		if (!list.isEmpty())
>-			event = (ITimeEvent) list.get(0);
>-		return event;
>+		Iterator<ITimeEvent> iterator = thread.getTraceEventsIterator();
>+		if (iterator.hasNext()) {
>+		    return iterator.next();
>+		} else {
>+		    return null;
>+		}
> 	}
> 
> 	/**
>@@ -343,14 +341,13 @@
>     static ITimeEvent findEvent(ITmfTimeAnalysisEntry thread, long time, int n) {
>         if (null == thread)
>             return null;
>-        List<TimeEvent> list = thread.getTraceEvents();
>-        Iterator<TimeEvent> it = list.iterator();
>+        Iterator<ITimeEvent> iterator = thread.getTraceEventsIterator();
>         ITimeEvent nextEvent = null;
>         ITimeEvent currEvent = null;
>         ITimeEvent prevEvent = null;
> 
>-        while (it.hasNext()) {
>-            nextEvent = (ITimeEvent) it.next();
>+        while (iterator.hasNext()) {
>+            nextEvent = (ITimeEvent) iterator.next();
>             long nextStartTime = nextEvent.getTime();
>             
>             if (nextStartTime > time) {
>Index: src/org/eclipse/linuxtools/tmf/ui/viewers/timeAnalysis/widgets/TmfTimeTipHandler.java
>===================================================================
>--- src/org/eclipse/linuxtools/tmf/ui/viewers/timeAnalysis/widgets/TmfTimeTipHandler.java	(revision 27125)
>+++ src/org/eclipse/linuxtools/tmf/ui/viewers/timeAnalysis/widgets/TmfTimeTipHandler.java	(working copy)
>@@ -107,28 +107,26 @@
> 					Item item) {
> 				if (item instanceof TraceItem) {
> 					ITmfTimeAnalysisEntry thrd = ((TraceItem) item)._trace;
>-					ITimeEvent threadEvent = Utils.findEvent(thrd, threadStates
>-							.hitTimeTest(pt.x, pt.y), 2);
>-					ITimeEvent nextEvent = Utils.findEvent(thrd, threadStates
>-							.hitTimeTest(pt.x, pt.y), 1);
>+					ITimeEvent threadEvent = Utils.findEvent(thrd, threadStates.hitTimeTest(pt.x), 2);
>+					ITimeEvent nextEvent = Utils.findEvent(thrd, threadStates.hitTimeTest(pt.x), 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);
>-					for (Iterator<String> iter = eventAddOns.keySet()
>-							.iterator(); iter.hasNext();) {
>-						String message = (String) iter.next();
>-						addItem(message, eventAddOns.get(message));
>+					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;
>Index: META-INF/MANIFEST.MF
>===================================================================
>--- META-INF/MANIFEST.MF	(revision 27125)
>+++ META-INF/MANIFEST.MF	(working copy)
>@@ -22,6 +22,7 @@
>  org.eclipse.linuxtools.tmf.ui.viewers.timeAnalysis.model,
>  org.eclipse.linuxtools.tmf.ui.viewers.timeAnalysis.widgets,
>  org.eclipse.linuxtools.tmf.ui.views,
>  org.eclipse.linuxtools.tmf.ui.views.project,
>+ org.eclipse.linuxtools.tmf.ui.views.timechart,
>  org.eclipse.linuxtools.tmf.ui.widgets
> Bundle-Localization: plugin
>Index: plugin.xml
>===================================================================
>--- plugin.xml	(revision 27125)
>+++ plugin.xml	(working copy)
>@@ -26,6 +26,14 @@
>             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">
>@@ -406,7 +414,6 @@
>    <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">
>Index: src/org/eclipse/linuxtools/tmf/ui/views/timechart/TimeChartAnalysisEntry.java
>===================================================================
>--- src/org/eclipse/linuxtools/tmf/ui/views/timechart/TimeChartAnalysisEntry.java	(revision 0)
>+++ src/org/eclipse/linuxtools/tmf/ui/views/timechart/TimeChartAnalysisEntry.java	(revision 0)
>@@ -0,0 +1,249 @@
>+/*******************************************************************************
>+ * 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;
>+    }
>+}
>Index: src/org/eclipse/linuxtools/tmf/ui/views/timechart/TimeChartAnalysisProvider.java
>===================================================================
>--- src/org/eclipse/linuxtools/tmf/ui/views/timechart/TimeChartAnalysisProvider.java	(revision 0)
>+++ src/org/eclipse/linuxtools/tmf/ui/views/timechart/TimeChartAnalysisProvider.java	(revision 0)
>@@ -0,0 +1,115 @@
>+/*******************************************************************************
>+ * 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);
>+    }
>+}
>Index: src/org/eclipse/linuxtools/tmf/ui/views/timechart/TimeChartDecorationProvider.java
>===================================================================
>--- src/org/eclipse/linuxtools/tmf/ui/views/timechart/TimeChartDecorationProvider.java	(revision 0)
>+++ src/org/eclipse/linuxtools/tmf/ui/views/timechart/TimeChartDecorationProvider.java	(revision 0)
>@@ -0,0 +1,81 @@
>+/*******************************************************************************
>+ * 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;
>+	}
>+	
>+}
>Index: src/org/eclipse/linuxtools/tmf/ui/views/timechart/TimeChartEvent.java
>===================================================================
>--- src/org/eclipse/linuxtools/tmf/ui/views/timechart/TimeChartEvent.java	(revision 0)
>+++ src/org/eclipse/linuxtools/tmf/ui/views/timechart/TimeChartEvent.java	(revision 0)
>@@ -0,0 +1,226 @@
>+/*******************************************************************************
>+ * 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;
>+            }
>+        }
>+    }
>+}
>Index: src/org/eclipse/linuxtools/tmf/ui/views/timechart/TimeChartView.java
>===================================================================
>--- src/org/eclipse/linuxtools/tmf/ui/views/timechart/TimeChartView.java	(revision 0)
>+++ src/org/eclipse/linuxtools/tmf/ui/views/timechart/TimeChartView.java	(revision 0)
>@@ -0,0 +1,581 @@
>+/*******************************************************************************
>+ * 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);
>+    }
>+
>+}
>#P org.eclipse.linuxtools.tmf.ui.tests
>Index: widgetStubs/org/eclipse/linuxtools/tmf/ui/widgets/timeAnalysis/test/stub/model/TraceModelImplFactory.java
>===================================================================
>--- widgetStubs/org/eclipse/linuxtools/tmf/ui/widgets/timeAnalysis/test/stub/model/TraceModelImplFactory.java	(revision 27108)
>+++ widgetStubs/org/eclipse/linuxtools/tmf/ui/widgets/timeAnalysis/test/stub/model/TraceModelImplFactory.java	(working copy)
>@@ -84,7 +84,7 @@
> 
> 			event = new EventImpl(eventTime, trace, getEventType(i%16));
> 			event.setDuration(duration);
>-			trace.getTraceEvents().add(event);
>+			trace.addTraceEvent(event);
> 		}
> 	}
> 
>@@ -99,7 +99,7 @@
> //			duration = i  + (long) ((i % 4));
> 			event = new EventImpl(eventTime, trace, getEventType(i));
> 			event.setDuration(duration);
>-			trace.getTraceEvents().add(event);
>+			trace.addTraceEvent(event);
> 		}
> 	}
> 
>Index: widgetStubs/org/eclipse/linuxtools/tmf/ui/widgets/timeAnalysis/test/stub/model/TraceImpl.java
>===================================================================
>--- widgetStubs/org/eclipse/linuxtools/tmf/ui/widgets/timeAnalysis/test/stub/model/TraceImpl.java	(revision 27108)
>+++ widgetStubs/org/eclipse/linuxtools/tmf/ui/widgets/timeAnalysis/test/stub/model/TraceImpl.java	(working copy)
>@@ -11,10 +11,11 @@
>  *******************************************************************************/
> 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 {
>@@ -27,7 +28,7 @@
> 	private long stopTime = 1;
> 	private String groupName = "defaultGroupName";
> 	private String className = "defaultClassName";
>-	private Vector<TimeEvent> traceEvents = new Vector<TimeEvent>();
>+	private Vector<ITimeEvent> traceEvents = new Vector<ITimeEvent>();
> 	
> 	// ========================================================================
> 	// Constructor
>@@ -101,9 +102,23 @@
> 	}
> 
> 	@Override
>-	@SuppressWarnings("unchecked")
>-	public Vector<TimeEvent> getTraceEvents() {
>+	@Deprecated public Vector<ITimeEvent> 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);
>+    }
> 
> }
>Index: widgetStubs/org/eclipse/linuxtools/tmf/ui/widgets/timeAnalysis/test/stub/views/TsfTraceAnalysisView.java
>===================================================================
>--- widgetStubs/org/eclipse/linuxtools/tmf/ui/widgets/timeAnalysis/test/stub/views/TsfTraceAnalysisView.java	(revision 27108)
>+++ widgetStubs/org/eclipse/linuxtools/tmf/ui/widgets/timeAnalysis/test/stub/views/TsfTraceAnalysisView.java	(working copy)
>@@ -35,10 +35,10 @@
> 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;
>@@ -596,7 +596,8 @@
> 		viewer.getControl().setFocus();
> 	}
> 
>-	@Override
>+	@SuppressWarnings("deprecation")
>+    @Override
> 	public void tsfTmProcessSelEvent(TmfTimeSelectionEvent event) {
> 		Object source = event.getSource();
> 		if (source == null || !(source instanceof ITimeAnalysisViewer)) {

Flags:

jjohnstn: iplog+

Actions: View | Diff

Attachments on bug 325016: 178665 | 184142 | 184392 | 189664 | 189665