[deliverable/tracecompass.git] / org.eclipse.linuxtools.tmf.ui / src / org / eclipse / linuxtools / tmf / ui / widgets / timegraph / widgets / TimeGraphControl.java

/*****************************************************************************\r
 * Copyright (c) 2007, 2008 Intel Corporation, 2009, 2010, 2011, 2012 Ericsson.\r
 * All rights reserved. This program and the accompanying materials\r
 * are made available under the terms of the Eclipse Public License v1.0\r
 * which accompanies this distribution, and is available at\r
 * http://www.eclipse.org/legal/epl-v10.html\r
 *\r
 * Contributors:\r
 *   Intel Corporation - Initial API and implementation\r
 *   Ruslan A. Scherbakov, Intel - Initial API and implementation\r
 *   Alvaro Sanchez-Leon - Updated for TMF\r
 *   Patrick Tasse - Refactoring\r
 *\r
 *****************************************************************************/\r
\r
package org.eclipse.linuxtools.tmf.ui.widgets.timegraph.widgets;\r
\r
import java.util.ArrayList;\r
import java.util.Iterator;\r
import java.util.List;\r
import java.util.Vector;\r
\r
import org.eclipse.jface.resource.JFaceResources;\r
import org.eclipse.jface.resource.LocalResourceManager;\r
import org.eclipse.jface.viewers.ISelection;\r
import org.eclipse.jface.viewers.ISelectionChangedListener;\r
import org.eclipse.jface.viewers.ISelectionProvider;\r
import org.eclipse.linuxtools.tmf.ui.widgets.timegraph.ITimeGraphPresentationProvider;\r
import org.eclipse.linuxtools.tmf.ui.widgets.timegraph.ITimeGraphTreeListener;\r
import org.eclipse.linuxtools.tmf.ui.widgets.timegraph.StateItem;\r
import org.eclipse.linuxtools.tmf.ui.widgets.timegraph.TimeGraphTreeExpansionEvent;\r
import org.eclipse.linuxtools.tmf.ui.widgets.timegraph.model.ITimeEvent;\r
import org.eclipse.linuxtools.tmf.ui.widgets.timegraph.model.ITimeGraphEntry;\r
import org.eclipse.swt.SWT;\r
import org.eclipse.swt.events.ControlEvent;\r
import org.eclipse.swt.events.ControlListener;\r
import org.eclipse.swt.events.FocusEvent;\r
import org.eclipse.swt.events.FocusListener;\r
import org.eclipse.swt.events.KeyEvent;\r
import org.eclipse.swt.events.KeyListener;\r
import org.eclipse.swt.events.MouseEvent;\r
import org.eclipse.swt.events.MouseListener;\r
import org.eclipse.swt.events.MouseMoveListener;\r
import org.eclipse.swt.events.MouseTrackListener;\r
import org.eclipse.swt.events.MouseWheelListener;\r
import org.eclipse.swt.events.PaintEvent;\r
import org.eclipse.swt.events.SelectionEvent;\r
import org.eclipse.swt.events.SelectionListener;\r
import org.eclipse.swt.events.TraverseEvent;\r
import org.eclipse.swt.events.TraverseListener;\r
import org.eclipse.swt.graphics.Color;\r
import org.eclipse.swt.graphics.Cursor;\r
import org.eclipse.swt.graphics.GC;\r
import org.eclipse.swt.graphics.Image;\r
import org.eclipse.swt.graphics.Point;\r
import org.eclipse.swt.graphics.Rectangle;\r
import org.eclipse.swt.widgets.Composite;\r
import org.eclipse.swt.widgets.Display;\r
import org.eclipse.swt.widgets.Event;\r
import org.eclipse.swt.widgets.Listener;\r
import org.eclipse.swt.widgets.ScrollBar;\r
\r
/**\r
 * Time graph control implementation\r
 *\r
 * @version 1.0\r
 * @author Alvaro Sanchez-Leon\r
 * @author Patrick Tasse\r
 */\r
public class TimeGraphControl extends TimeGraphBaseControl implements FocusListener, KeyListener, MouseMoveListener, MouseListener, MouseWheelListener, ControlListener, SelectionListener, MouseTrackListener, TraverseListener, ISelectionProvider {\r
\r
    private static final int DRAG_NONE = 0;\r
    private static final int DRAG_TRACE_ITEM = 1;\r
    private static final int DRAG_SPLIT_LINE = 2;\r
    public static final boolean DEFAULT_DRAW_THREAD_JOIN = true;\r
    public static final boolean DEFAULT_DRAW_THREAD_WAIT = true;\r
    public static final boolean DEFAULT_DRAW_THREAD_RELEASE = true;\r
    public static final int H_SCROLLBAR_MAX = Integer.MAX_VALUE - 1;\r
    private static final int CUSTOM_ITEM_HEIGHT = -1; // get item height from provider\r
\r
    private static final double zoomCoeff = 1.5;\r
\r
    private ITimeDataProvider _timeProvider;\r
    private boolean _isInFocus = false;\r
    private boolean _isDragCursor3 = false;\r
    private boolean _isWaitCursor = true;\r
    private boolean _mouseOverSplitLine = false;\r
    private int _itemHeight = CUSTOM_ITEM_HEIGHT;\r
    private int _minimumItemWidth = 0;\r
    private int _topIndex = 0;\r
    private int _dragState = DRAG_NONE;\r
    private int _dragX0 = 0;\r
    private int _dragX = 0;\r
    private int _idealNameSpace = 0;\r
    // private double _timeStep = 10000000;\r
    private long _time0bak;\r
    private long _time1bak;\r
    private ITimeGraphPresentationProvider fTimeGraphProvider = null;\r
    private ItemData _data = null;\r
    private List<SelectionListener> _selectionListeners;\r
    private final List<ISelectionChangedListener> _selectionChangedListeners = new ArrayList<ISelectionChangedListener>();\r
    private final List<ITimeGraphTreeListener> _treeListeners = new ArrayList<ITimeGraphTreeListener>();\r
    private final Cursor _dragCursor3;\r
    private final Cursor _WaitCursor;\r
\r
    // Vertical formatting formatting for the state control view\r
    private final boolean _visibleVerticalScroll = true;\r
    private int _borderWidth = 0;\r
    private int _headerHeight = 0;\r
\r
    private Listener mouseScrollFilterListener;\r
\r
    protected LocalResourceManager fResourceManager = new LocalResourceManager(JFaceResources.getResources());\r
    protected Color[] fEventColorMap = null;\r
\r
    private MouseScrollNotifier fMouseScrollNotifier;\r
    private final Object fMouseScrollNotifierLock = new Object();\r
    private class MouseScrollNotifier extends Thread {\r
        private final static long DELAY = 400L;\r
        private final static long POLLING_INTERVAL = 10L;\r
        private long fLastScrollTime = Long.MAX_VALUE;\r
\r
        @Override\r
        public void run() {\r
            while ((System.currentTimeMillis() - fLastScrollTime) < DELAY) {\r
                try {\r
                    Thread.sleep(POLLING_INTERVAL);\r
                } catch (Exception e) {\r
                    return;\r
                }\r
            }\r
            if (!isInterrupted()) {\r
                Display.getDefault().asyncExec(new Runnable() {\r
                    @Override\r
                    public void run() {\r
                        if (isDisposed()) {\r
                            return;\r
                        }\r
                        _timeProvider.notifyStartFinishTime();\r
                    }\r
                });\r
            }\r
            synchronized (fMouseScrollNotifierLock) {\r
                fMouseScrollNotifier = null;\r
            }\r
        }\r
\r
        public void mouseScrolled() {\r
            fLastScrollTime = System.currentTimeMillis();\r
        }\r
    }\r
\r
    /**\r
     * Standard constructor\r
     *\r
     * @param parent\r
     *            The parent composite object\r
     * @param colors\r
     *            The color scheme to use\r
     */\r
    public TimeGraphControl(Composite parent, TimeGraphColorScheme colors) {\r
\r
        super(parent, colors, SWT.NO_BACKGROUND | SWT.H_SCROLL | SWT.DOUBLE_BUFFERED);\r
\r
        _data = new ItemData();\r
\r
        addFocusListener(this);\r
        addMouseListener(this);\r
        addMouseMoveListener(this);\r
        addMouseTrackListener(this);\r
        addMouseWheelListener(this);\r
        addTraverseListener(this);\r
        addKeyListener(this);\r
        addControlListener(this);\r
        ScrollBar scrollHor = getHorizontalBar();\r
\r
        if (scrollHor != null) {\r
            scrollHor.addSelectionListener(this);\r
        }\r
\r
        _dragCursor3 = new Cursor(super.getDisplay(), SWT.CURSOR_SIZEWE);\r
        _WaitCursor = new Cursor(super.getDisplay(), SWT.CURSOR_WAIT);\r
    }\r
\r
    @Override\r
    public void dispose() {\r
        super.dispose();\r
        _dragCursor3.dispose();\r
        _WaitCursor.dispose();\r
        fResourceManager.dispose();\r
    }\r
\r
    /**\r
     * Sets the timegraph provider used by this timegraph viewer.\r
     *\r
     * @param timeGraphProvider the timegraph provider\r
     */\r
    public void setTimeGraphProvider(ITimeGraphPresentationProvider timeGraphProvider) {\r
        fTimeGraphProvider = timeGraphProvider;\r
        _data.provider = timeGraphProvider;\r
\r
        if (fEventColorMap != null) {\r
            for (Color color : fEventColorMap) {\r
                fResourceManager.destroyColor(color.getRGB());\r
            }\r
        }\r
        StateItem[] stateItems = fTimeGraphProvider.getStateTable();\r
        if (stateItems != null) {\r
            fEventColorMap = new Color[stateItems.length];\r
            for (int i = 0; i < stateItems.length; i++) {\r
                fEventColorMap[i] = fResourceManager.createColor(stateItems[i].getStateColor());\r
            }\r
        } else {\r
            fEventColorMap = new Color[] { };\r
        }\r
    }\r
\r
    /**\r
     * Assign the given time provider\r
     *\r
     * @param timeProvider\r
     *            The time provider\r
     */\r
    public void setTimeProvider(ITimeDataProvider timeProvider) {\r
        _timeProvider = timeProvider;\r
        adjustScrolls();\r
        redraw();\r
    }\r
\r
    /**\r
     * Add a selection listener\r
     *\r
     * @param listener\r
     *            The listener to add\r
     */\r
    public void addSelectionListener(SelectionListener listener) {\r
        if (listener == null) {\r
            SWT.error(SWT.ERROR_NULL_ARGUMENT);\r
        }\r
        if (null == _selectionListeners) {\r
            _selectionListeners = new ArrayList<SelectionListener>();\r
        }\r
        _selectionListeners.add(listener);\r
    }\r
\r
    /**\r
     * Remove a selection listener\r
     *\r
     * @param listener\r
     *            The listener to remove\r
     */\r
    public void removeSelectionListener(SelectionListener listener) {\r
        if (null != _selectionListeners) {\r
            _selectionListeners.remove(listener);\r
        }\r
    }\r
\r
    /**\r
     * Selection changed callback\r
     */\r
    public void fireSelectionChanged() {\r
        if (null != _selectionListeners) {\r
            Iterator<SelectionListener> it = _selectionListeners.iterator();\r
            while (it.hasNext()) {\r
                SelectionListener listener = it.next();\r
                listener.widgetSelected(null);\r
            }\r
        }\r
    }\r
\r
    /**\r
     * Default selection callback\r
     */\r
    public void fireDefaultSelection() {\r
        if (null != _selectionListeners) {\r
            Iterator<SelectionListener> it = _selectionListeners.iterator();\r
            while (it.hasNext()) {\r
                SelectionListener listener = it.next();\r
                listener.widgetDefaultSelected(null);\r
            }\r
        }\r
    }\r
\r
    /**\r
     * Get the traces in the model\r
     *\r
     * @return The array of traces\r
     */\r
    public ITimeGraphEntry[] getTraces() {\r
        return _data.getTraces();\r
    }\r
\r
    /**\r
     * Get the on/off trace filters\r
     *\r
     * @return The array of filters\r
     */\r
    public boolean[] getTraceFilter() {\r
        return _data.getTraceFilter();\r
    }\r
\r
    /**\r
     * Refresh the data for the thing\r
     */\r
    public void refreshData() {\r
        _data.refreshData();\r
        adjustScrolls();\r
        redraw();\r
    }\r
\r
    /**\r
     * Refresh data for the given traces\r
     *\r
     * @param traces\r
     *            The traces to refresh\r
     */\r
    public void refreshData(ITimeGraphEntry[] traces) {\r
        _data.refreshData(traces);\r
        adjustScrolls();\r
        redraw();\r
    }\r
\r
    /**\r
     * Adjust the scoll bars\r
     */\r
    public void adjustScrolls() {\r
        if (null == _timeProvider) {\r
            getHorizontalBar().setValues(0, 1, 1, 1, 1, 1);\r
            return;\r
        }\r
\r
        // HORIZONTAL BAR\r
        // Visible window\r
        long time0 = _timeProvider.getTime0();\r
        long time1 = _timeProvider.getTime1();\r
        // Time boundaries\r
        long timeMin = _timeProvider.getMinTime();\r
        long timeMax = _timeProvider.getMaxTime();\r
\r
        long delta = timeMax - timeMin;\r
\r
        int timePos = 0;\r
        int thumb = H_SCROLLBAR_MAX;\r
\r
        if (delta != 0) {\r
            // Thumb size (page size)\r
            thumb = Math.max(1, (int) (H_SCROLLBAR_MAX * ((double) (time1 - time0) / delta)));\r
            // At the beginning of visible window\r
            timePos = (int) (H_SCROLLBAR_MAX * ((double) (time0 - timeMin) / delta));\r
        }\r
\r
        // position, minimum, maximum, thumb size, increment (half page)t, page\r
        // increment size (full page)\r
        getHorizontalBar().setValues(timePos, 0, H_SCROLLBAR_MAX, thumb, Math.max(1, thumb / 2), Math.max(2, thumb));\r
    }\r
\r
    boolean ensureVisibleItem(int idx, boolean redraw) {\r
        boolean changed = false;\r
        if (idx < 0) {\r
            for (idx = 0; idx < _data._expandedItems.length; idx++) {\r
                if (_data._expandedItems[idx]._selected) {\r
                    break;\r
                }\r
            }\r
        }\r
        if (idx >= _data._expandedItems.length) {\r
            return changed;\r
        }\r
        if (idx < _topIndex) {\r
            setTopIndex(idx);\r
            //FIXME:getVerticalBar().setSelection(_topItem);\r
            if (redraw) {\r
                redraw();\r
            }\r
            changed = true;\r
        } else {\r
            int page = countPerPage();\r
            if (idx >= _topIndex + page) {\r
                setTopIndex(idx - page + 1);\r
                //FIXME:getVerticalBar().setSelection(_topItem);\r
                if (redraw) {\r
                    redraw();\r
                }\r
                changed = true;\r
            }\r
        }\r
        return changed;\r
    }\r
\r
    /**\r
     * Assign the given index as the top one\r
     *\r
     * @param idx\r
     *            The index\r
     */\r
    public void setTopIndex(int idx) {\r
        idx = Math.min(idx, _data._expandedItems.length - countPerPage());\r
        idx = Math.max(0,  idx);\r
        _topIndex = idx;\r
        redraw();\r
    }\r
\r
    /**\r
     * Set the expanded state of a given entry\r
     *\r
     * @param entry\r
     *            The entry\r
     * @param expanded\r
     *            True if expanded, false if collapsed\r
     */\r
    public void setExpandedState(ITimeGraphEntry entry, boolean expanded) {\r
        Item item = _data.findItem(entry);\r
        if (item != null && item._expanded != expanded) {\r
            item._expanded = expanded;\r
            _data.updateExpandedItems();\r
            redraw();\r
        }\r
    }\r
\r
    /**\r
     * Add a tree listener\r
     *\r
     * @param listener\r
     *            The listener to add\r
     */\r
    public void addTreeListener(ITimeGraphTreeListener listener) {\r
        if (!_treeListeners.contains(listener)) {\r
            _treeListeners.add(listener);\r
        }\r
    }\r
\r
    /**\r
     * Remove a tree listener\r
     *\r
     * @param listener\r
     *            The listener to remove\r
     */\r
    public void removeTreeListener(ITimeGraphTreeListener listener) {\r
        if (_treeListeners.contains(listener)) {\r
            _treeListeners.remove(listener);\r
        }\r
    }\r
\r
    /**\r
     * Tree event callback\r
     *\r
     * @param entry\r
     *            The affected entry\r
     * @param expanded\r
     *            The expanded state (true for expanded, false for collapsed)\r
     */\r
    public void fireTreeEvent(ITimeGraphEntry entry, boolean expanded) {\r
        TimeGraphTreeExpansionEvent event = new TimeGraphTreeExpansionEvent(this, entry);\r
        for (ITimeGraphTreeListener listener : _treeListeners) {\r
            if (expanded) {\r
                listener.treeExpanded(event);\r
            } else {\r
                listener.treeCollapsed(event);\r
            }\r
        }\r
    }\r
\r
    @Override\r
    public ISelection getSelection() {\r
        TimeGraphSelection sel = new TimeGraphSelection();\r
        ITimeGraphEntry trace = getSelectedTrace();\r
        if (null != trace && null != _timeProvider) {\r
            long selectedTime = _timeProvider.getSelectedTime();\r
            ITimeEvent event = Utils.findEvent(trace, selectedTime, 0);\r
            if (event != null) {\r
                sel.add(event);\r
            } else {\r
                sel.add(trace);\r
            }\r
        }\r
        return sel;\r
    }\r
\r
    /**\r
     * Get the selection object\r
     *\r
     * @return The selection\r
     */\r
    public ISelection getSelectionTrace() {\r
        TimeGraphSelection sel = new TimeGraphSelection();\r
        ITimeGraphEntry trace = getSelectedTrace();\r
        if (null != trace) {\r
            sel.add(trace);\r
        }\r
        return sel;\r
    }\r
\r
    /**\r
     * Enable/disable one of the traces in the model\r
     *\r
     * @param n\r
     *            1 to enable it, -1 to disable. The method returns immediately\r
     *            if another value is used.\r
     */\r
    public void selectTrace(int n) {\r
        if ((n != 1) && (n != -1)) {\r
            return;\r
        }\r
\r
        boolean changed = false;\r
        int lastSelection = -1;\r
        for (int i = 0; i < _data._expandedItems.length; i++) {\r
            Item item = _data._expandedItems[i];\r
            if (item._selected) {\r
                lastSelection = i;\r
                if ((1 == n) && (i < _data._expandedItems.length - 1)) {\r
                    item._selected = false;\r
                    item = _data._expandedItems[i + 1];\r
                    item._selected = true;\r
                    changed = true;\r
                } else if ((-1 == n) && (i > 0)) {\r
                    item._selected = false;\r
                    item = _data._expandedItems[i - 1];\r
                    item._selected = true;\r
                    changed = true;\r
                }\r
                break;\r
            }\r
        }\r
\r
        if (lastSelection < 0 && _data._expandedItems.length > 0) {\r
            Item item = _data._expandedItems[0];\r
            item._selected = true;\r
            changed = true;\r
        }\r
\r
        if (changed) {\r
            ensureVisibleItem(-1, false);\r
            redraw();\r
            fireSelectionChanged();\r
        }\r
    }\r
\r
    /**\r
     * Select an event\r
     *\r
     * @param n\r
     *            1 for next event, -1 for previous event\r
     */\r
    public void selectEvent(int n) {\r
        if (null == _timeProvider) {\r
            return;\r
        }\r
        ITimeGraphEntry trace = getSelectedTrace();\r
        if (trace == null) {\r
            return;\r
        }\r
        long selectedTime = _timeProvider.getSelectedTime();\r
        long endTime = _timeProvider.getEndTime();\r
        ITimeEvent nextEvent;\r
        if (-1 == n && selectedTime > endTime) {\r
            nextEvent = Utils.findEvent(trace, selectedTime, 0);\r
        } else {\r
            nextEvent = Utils.findEvent(trace, selectedTime, n);\r
        }\r
        if (null == nextEvent && -1 == n) {\r
            nextEvent = Utils.getFirstEvent(trace);\r
        }\r
        if (null != nextEvent) {\r
            long nextTime = nextEvent.getTime();\r
            // If last event detected e.g. going back or not moving to a next\r
            // event\r
            if (nextTime <= selectedTime && n == 1) {\r
                // Select to the end of this last event\r
                nextTime = nextEvent.getTime() + nextEvent.getDuration();\r
                // but not beyond the end of the trace\r
                if (nextTime > endTime) {\r
                    nextTime = endTime;\r
                }\r
            } else if (n == -1) {\r
                // for previous event go to its end time unless we were already there\r
                if (nextEvent.getTime() + nextEvent.getDuration() < selectedTime) {\r
                    nextTime = nextEvent.getTime() + nextEvent.getDuration();\r
                }\r
            }\r
            _timeProvider.setSelectedTimeNotify(nextTime, true);\r
            fireSelectionChanged();\r
        } else if (1 == n) {\r
            _timeProvider.setSelectedTimeNotify(endTime, true);\r
            fireSelectionChanged();\r
        }\r
    }\r
\r
    /**\r
     * Select the next event\r
     */\r
    public void selectNextEvent() {\r
        selectEvent(1);\r
        // Notify if visible time window has been adjusted\r
        _timeProvider.setStartFinishTimeNotify(_timeProvider.getTime0(), _timeProvider.getTime1());\r
    }\r
\r
    /**\r
     * Select the previous event\r
     */\r
    public void selectPrevEvent() {\r
        selectEvent(-1);\r
        // Notify if visible time window has been adjusted\r
        _timeProvider.setStartFinishTimeNotify(_timeProvider.getTime0(), _timeProvider.getTime1());\r
    }\r
\r
    /**\r
     * Select the next trace\r
     */\r
    public void selectNextTrace() {\r
        selectTrace(1);\r
    }\r
\r
    /**\r
     * Select the previous trace\r
     */\r
    public void selectPrevTrace() {\r
        selectTrace(-1);\r
    }\r
\r
    /**\r
     * Zoom based on mouse cursor location with mouse scrolling\r
     *\r
     * @param zoomIn true to zoom in, false to zoom out\r
     */\r
    public void zoom(boolean zoomIn) {\r
        int globalX = getDisplay().getCursorLocation().x;\r
        Point p = toControl(globalX, 0);\r
        int nameSpace = _timeProvider.getNameSpace();\r
        int timeSpace = _timeProvider.getTimeSpace();\r
        int xPos = Math.max(nameSpace, Math.min(nameSpace + timeSpace, p.x));\r
        long time0 = _timeProvider.getTime0();\r
        long time1 = _timeProvider.getTime1();\r
        long interval = time1 - time0;\r
        if (interval == 0) {\r
            interval = 1;\r
        } // to allow getting out of single point interval\r
        long newInterval;\r
        if (zoomIn) {\r
            newInterval = Math.max(Math.round(interval * 0.8), _timeProvider.getMinTimeInterval());\r
        } else {\r
            newInterval = (long) Math.ceil(interval * 1.25);\r
        }\r
        long center = time0 + Math.round(((double) (xPos - nameSpace) / timeSpace * interval));\r
        long newTime0 = center - Math.round((double) newInterval * (center - time0) / interval);\r
        long newTime1 = newTime0 + newInterval;\r
        _timeProvider.setStartFinishTime(newTime0, newTime1);\r
        synchronized (fMouseScrollNotifierLock) {\r
            if (fMouseScrollNotifier == null) {\r
                fMouseScrollNotifier = new MouseScrollNotifier();\r
                fMouseScrollNotifier.start();\r
            }\r
            fMouseScrollNotifier.mouseScrolled();\r
        }\r
    }\r
\r
    /**\r
     * zoom in using single click\r
     */\r
    public void zoomIn() {\r
        long _time0 = _timeProvider.getTime0();\r
        long _time1 = _timeProvider.getTime1();\r
        long _range = _time1 - _time0;\r
        long selTime = _timeProvider.getSelectedTime();\r
        if (selTime <= _time0 || selTime >= _time1) {\r
            selTime = (_time0 + _time1) / 2;\r
        }\r
        long time0 = selTime - (long) ((selTime - _time0) / zoomCoeff);\r
        long time1 = selTime + (long) ((_time1 - selTime) / zoomCoeff);\r
\r
        long inaccuracy = (_timeProvider.getMaxTime() - _timeProvider.getMinTime()) - (time1 - time0);\r
\r
        // Trace.debug("selTime:" + selTime + " time0:" + time0 + " time1:"\r
        // + time1 + " inaccuracy:" + inaccuracy);\r
\r
        if (inaccuracy > 0 && inaccuracy < 100) {\r
            _timeProvider.setStartFinishTimeNotify(_timeProvider.getMinTime(), _timeProvider.getMaxTime());\r
            return;\r
        }\r
\r
        long m = _timeProvider.getMinTimeInterval();\r
        if ((time1 - time0) < m) {\r
            time0 = selTime - (selTime - _time0) * m / _range;\r
            time1 = time0 + m;\r
        }\r
\r
        _timeProvider.setStartFinishTimeNotify(time0, time1);\r
    }\r
\r
    /**\r
     * zoom out using single click\r
     */\r
    public void zoomOut() {\r
        long _time0 = _timeProvider.getTime0();\r
        long _time1 = _timeProvider.getTime1();\r
        long selTime = _timeProvider.getSelectedTime();\r
        if (selTime <= _time0 || selTime >= _time1) {\r
            selTime = (_time0 + _time1) / 2;\r
        }\r
        long time0 = (long) (selTime - (selTime - _time0) * zoomCoeff);\r
        long time1 = (long) (selTime + (_time1 - selTime) * zoomCoeff);\r
\r
        long inaccuracy = (_timeProvider.getMaxTime() - _timeProvider.getMinTime()) - (time1 - time0);\r
        if (inaccuracy > 0 && inaccuracy < 100) {\r
            _timeProvider.setStartFinishTimeNotify(_timeProvider.getMinTime(), _timeProvider.getMaxTime());\r
            return;\r
        }\r
\r
        _timeProvider.setStartFinishTimeNotify(time0, time1);\r
    }\r
\r
    /**\r
     * Return the currently selected trace\r
     *\r
     * @return The entry matching the trace\r
     */\r
    public ITimeGraphEntry getSelectedTrace() {\r
        ITimeGraphEntry trace = null;\r
        int idx = getSelectedIndex();\r
        if (idx >= 0) {\r
            trace = _data._expandedItems[idx]._trace;\r
        }\r
        return trace;\r
    }\r
\r
    /**\r
     * Retrieve the index of the currently selected item\r
     *\r
     * @return The index\r
     */\r
    public int getSelectedIndex() {\r
        int idx = -1;\r
        for (int i = 0; i < _data._expandedItems.length; i++) {\r
            Item item = _data._expandedItems[i];\r
            if (item._selected) {\r
                idx = i;\r
                break;\r
            }\r
        }\r
        return idx;\r
    }\r
\r
    boolean toggle(int idx) {\r
        boolean toggled = false;\r
        if (idx >= 0 && idx < _data._expandedItems.length) {\r
            Item item = _data._expandedItems[idx];\r
            if (item._hasChildren) {\r
                item._expanded = !item._expanded;\r
                _data.updateExpandedItems();\r
                adjustScrolls();\r
                redraw();\r
                toggled = true;\r
                fireTreeEvent(item._trace, item._expanded);\r
            }\r
        }\r
        return toggled;\r
    }\r
\r
    int getItemIndexAtY(int y) {\r
        if (y < 0) {\r
            return -1;\r
        }\r
        if (_itemHeight == CUSTOM_ITEM_HEIGHT) {\r
            int ySum = 0;\r
            for (int idx = _topIndex; idx < _data._expandedItems.length; idx++) {\r
                ySum += _data._expandedItems[idx].itemHeight;\r
                if (y < ySum) {\r
                    return idx;\r
                }\r
            }\r
            return -1;\r
        }\r
        int idx = y / _itemHeight;\r
        idx += _topIndex;\r
        if (idx < _data._expandedItems.length) {\r
            return idx;\r
        }\r
        return -1;\r
    }\r
\r
    boolean isOverSplitLine(int x) {\r
        if (x < 0 || null == _timeProvider) {\r
            return false;\r
        }\r
        int w = 4;\r
        int nameWidth = _timeProvider.getNameSpace();\r
        if (x > nameWidth - w && x < nameWidth + w) {\r
            return true;\r
        }\r
        return false;\r
    }\r
\r
    ITimeGraphEntry getEntry(Point pt) {\r
        int idx = getItemIndexAtY(pt.y);\r
        return idx >= 0 ? _data._expandedItems[idx]._trace : null;\r
    }\r
\r
    long getTimeAtX(int x) {\r
        if (null == _timeProvider) {\r
            return -1;\r
        }\r
        long hitTime = -1;\r
        Point size = getCtrlSize();\r
        long time0 = _timeProvider.getTime0();\r
        long time1 = _timeProvider.getTime1();\r
        int nameWidth = _timeProvider.getNameSpace();\r
        x -= nameWidth;\r
        int timeWidth = size.x - nameWidth - RIGHT_MARGIN;\r
        if (x >= 0 && size.x >= nameWidth) {\r
            if (time1 - time0 > timeWidth) {\r
                // nanosecond smaller than one pixel: use the first integer nanosecond of this pixel's time range\r
                hitTime = time0 + (long) Math.ceil((time1 - time0) * ((double) x / timeWidth));\r
            } else {\r
                // nanosecond greater than one pixel: use the nanosecond that covers this pixel start position\r
                hitTime = time0 + (long) Math.floor((time1 - time0) * ((double) x / timeWidth));\r
            }\r
        }\r
        return hitTime;\r
    }\r
\r
    void selectItem(int idx, boolean addSelection) {\r
        boolean changed = false;\r
        if (addSelection) {\r
            if (idx >= 0 && idx < _data._expandedItems.length) {\r
                Item item = _data._expandedItems[idx];\r
                changed = (item._selected == false);\r
                item._selected = true;\r
            }\r
        } else {\r
            for (int i = 0; i < _data._expandedItems.length; i++) {\r
                Item item = _data._expandedItems[i];\r
                if ((i == idx && !item._selected) || (idx == -1 && item._selected)) {\r
                    changed = true;\r
                }\r
                item._selected = i == idx;\r
            }\r
        }\r
        changed |= ensureVisibleItem(idx, true);\r
        if (changed) {\r
            redraw();\r
        }\r
    }\r
\r
    /**\r
     * Callback for item selection\r
     *\r
     * @param trace\r
     *            The entry matching the trace\r
     * @param addSelection\r
     *            If the selection is added or removed\r
     */\r
    public void selectItem(ITimeGraphEntry trace, boolean addSelection) {\r
        int idx = _data.findItemIndex(trace);\r
        selectItem(idx, addSelection);\r
    }\r
\r
    /**\r
     * Retrieve the number of entries shown per page.\r
     *\r
     * @return The count\r
     */\r
    public int countPerPage() {\r
        int height = getCtrlSize().y;\r
        int count = 0;\r
        if (_itemHeight == CUSTOM_ITEM_HEIGHT) {\r
            int ySum = 0;\r
            for (int idx = _topIndex; idx < _data._expandedItems.length; idx++) {\r
                ySum += _data._expandedItems[idx].itemHeight;\r
                if (ySum >= height) {\r
                    return count;\r
                }\r
                count++;\r
            }\r
            for (int idx = _topIndex - 1; idx >= 0; idx--) {\r
                ySum += _data._expandedItems[idx].itemHeight;\r
                if (ySum >= height) {\r
                    return count;\r
                }\r
                count++;\r
            }\r
            return count;\r
        }\r
        if (height > 0) {\r
            count = height / _itemHeight;\r
        }\r
        return count;\r
    }\r
\r
    /**\r
     * Get the index of the top element\r
     *\r
     * @return The index\r
     */\r
    public int getTopIndex() {\r
        return _topIndex;\r
    }\r
\r
    /**\r
     * Get the number of expanded items\r
     *\r
     * @return The count of expanded items\r
     */\r
    public int getExpandedElementCount() {\r
        return _data._expandedItems.length;\r
    }\r
\r
    /**\r
     * Get an array of all expanded elements\r
     *\r
     * @return The expanded elements\r
     */\r
    public ITimeGraphEntry[] getExpandedElements() {\r
        ArrayList<ITimeGraphEntry> elements = new ArrayList<ITimeGraphEntry>();\r
        for (Item item : _data._expandedItems) {\r
            elements.add(item._trace);\r
        }\r
        return elements.toArray(new ITimeGraphEntry[0]);\r
    }\r
\r
    Point getCtrlSize() {\r
        Point size = getSize();\r
        if (getHorizontalBar().isVisible()) {\r
            size.y -= getHorizontalBar().getSize().y;\r
        }\r
        return size;\r
    }\r
\r
    Rectangle getNameRect(Rectangle bound, int idx, int nameWidth) {\r
        int x = bound.x;\r
        int y = bound.y + (idx - _topIndex) * _itemHeight;\r
        int width = nameWidth;\r
        int height = _itemHeight;\r
        if (_itemHeight == CUSTOM_ITEM_HEIGHT) {\r
            int ySum = 0;\r
            for (int i = _topIndex; i < idx; i++) {\r
                ySum += _data._expandedItems[i].itemHeight;\r
            }\r
            y = bound.y + ySum;\r
            height = _data._expandedItems[idx].itemHeight;\r
        }\r
        return new Rectangle(x, y, width, height);\r
    }\r
\r
    Rectangle getStatesRect(Rectangle bound, int idx, int nameWidth) {\r
        int x = bound.x + nameWidth;\r
        int y = bound.y + (idx - _topIndex) * _itemHeight;\r
        int width = bound.width - x;\r
        int height = _itemHeight;\r
        if (_itemHeight == CUSTOM_ITEM_HEIGHT) {\r
            int ySum = 0;\r
            for (int i = _topIndex; i < idx; i++) {\r
                ySum += _data._expandedItems[i].itemHeight;\r
            }\r
            y = bound.y + ySum;\r
            height = _data._expandedItems[idx].itemHeight;\r
        }\r
        return new Rectangle(x, y, width, height);\r
    }\r
\r
    @Override\r
    void paint(Rectangle bounds, PaintEvent e) {\r
        GC gc = e.gc;\r
        gc.setBackground(_colors.getColor(TimeGraphColorScheme.BACKGROUND));\r
        drawBackground(gc, bounds.x, bounds.y, bounds.width, bounds.height);\r
\r
        if (bounds.width < 2 || bounds.height < 2 || null == _timeProvider) {\r
            return;\r
        }\r
\r
        _idealNameSpace = 0;\r
        int nameSpace = _timeProvider.getNameSpace();\r
\r
        // draw empty name space background\r
        gc.setBackground(_colors.getBkColor(false, false, true));\r
        drawBackground(gc, bounds.x, bounds.y, nameSpace, bounds.height);\r
\r
        drawItems(bounds, _timeProvider, _data._expandedItems, _topIndex, nameSpace, gc);\r
\r
        // draw selected time\r
        long time0 = _timeProvider.getTime0();\r
        long time1 = _timeProvider.getTime1();\r
        long selectedTime = _timeProvider.getSelectedTime();\r
        double pixelsPerNanoSec = (bounds.width - nameSpace <= RIGHT_MARGIN) ? 0 : (double) (bounds.width - nameSpace - RIGHT_MARGIN) / (time1 - time0);\r
        int x = bounds.x + nameSpace + (int) ((selectedTime - time0) * pixelsPerNanoSec);\r
        if (x >= nameSpace && x < bounds.x + bounds.width) {\r
            gc.setForeground(_colors.getColor(TimeGraphColorScheme.SELECTED_TIME));\r
            gc.drawLine(x, bounds.y, x, bounds.y + bounds.height);\r
        }\r
\r
        // draw drag line, no line if name space is 0.\r
        if (DRAG_SPLIT_LINE == _dragState) {\r
            gc.setForeground(_colors.getColor(TimeGraphColorScheme.BLACK));\r
            gc.drawLine(bounds.x + nameSpace, bounds.y, bounds.x + nameSpace, bounds.y + bounds.height - 1);\r
        } else if (DRAG_NONE == _dragState && _mouseOverSplitLine && _timeProvider.getNameSpace() > 0) {\r
            gc.setForeground(_colors.getColor(TimeGraphColorScheme.RED));\r
            gc.drawLine(bounds.x + nameSpace, bounds.y, bounds.x + nameSpace, bounds.y + bounds.height - 1);\r
        }\r
    }\r
\r
    /**\r
     * Draw many items at once\r
     *\r
     * @param bounds\r
     *            The rectangle of the area\r
     * @param timeProvider\r
     *            The time provider\r
     * @param items\r
     *            The array items to draw\r
     * @param topIndex\r
     *            The index of the first element to draw\r
     * @param nameSpace\r
     *            The width reserved for the names\r
     * @param gc\r
     *            Reference to the SWT GC object\r
     */\r
    public void drawItems(Rectangle bounds, ITimeDataProvider timeProvider,\r
            Item[] items, int topIndex, int nameSpace, GC gc) {\r
        for (int i = topIndex; i < items.length; i++) {\r
            Item item = items[i];\r
            drawItem(item, bounds, timeProvider, i, nameSpace, gc);\r
        }\r
        fTimeGraphProvider.postDrawControl(bounds, gc);\r
    }\r
\r
    /**\r
     * Draws the item\r
     *\r
     * @param item the item to draw\r
     * @param bounds the container rectangle\r
     * @param i the item index\r
     * @param nameSpace the name space\r
     * @param gc\r
     */\r
    protected void drawItem(Item item, Rectangle bounds, ITimeDataProvider timeProvider, int i, int nameSpace, GC gc) {\r
        ITimeGraphEntry entry = item._trace;\r
        long time0 = timeProvider.getTime0();\r
        long time1 = timeProvider.getTime1();\r
        long selectedTime = timeProvider.getSelectedTime();\r
\r
        Rectangle nameRect = getNameRect(bounds, i, nameSpace);\r
        if (nameRect.y >= bounds.y + bounds.height) {\r
            return;\r
        }\r
\r
        if (! item._trace.hasTimeEvents()) {\r
            Rectangle statesRect = getStatesRect(bounds, i, nameSpace);\r
            nameRect.width += statesRect.width;\r
            drawName(item, nameRect, gc);\r
        } else {\r
            drawName(item, nameRect, gc);\r
        }\r
        Rectangle rect = getStatesRect(bounds, i, nameSpace);\r
        if (rect.isEmpty()) {\r
            fTimeGraphProvider.postDrawEntry(entry, rect, gc);\r
            return;\r
        }\r
        if (time1 <= time0) {\r
            gc.setBackground(_colors.getBkColor(false, false, false));\r
            gc.fillRectangle(rect);\r
            fTimeGraphProvider.postDrawEntry(entry, rect, gc);\r
            return;\r
        }\r
\r
        // Initialize _rect1 to same values as enclosing rectangle rect\r
        Rectangle stateRect = Utils.clone(rect);\r
        boolean selected = item._selected;\r
        // K pixels per second\r
        double pixelsPerNanoSec = (rect.width <= RIGHT_MARGIN) ? 0 : (double) (rect.width - RIGHT_MARGIN) / (time1 - time0);\r
\r
        if (item._trace.hasTimeEvents()) {\r
            fillSpace(rect, gc, selected);\r
            // Drawing rectangle is smaller than reserved space\r
            stateRect.y += 3;\r
            stateRect.height -= 6;\r
\r
            long maxDuration = (timeProvider.getTimeSpace() == 0) ? Long.MAX_VALUE : 1 * (time1 - time0) / timeProvider.getTimeSpace();\r
            Iterator<ITimeEvent> iterator = entry.getTimeEventsIterator(time0, time1, maxDuration);\r
\r
            int lastX = -1;\r
            while (iterator.hasNext()) {\r
                ITimeEvent event = iterator.next();\r
                int x = rect.x + (int) ((event.getTime() - time0) * pixelsPerNanoSec);\r
                int xEnd = rect.x + (int) ((event.getTime() + event.getDuration() - time0) * pixelsPerNanoSec);\r
                if (x >= rect.x + rect.width || xEnd < rect.x) {\r
                    // event is out of bounds\r
                    continue;\r
                }\r
                xEnd = Math.min(rect.x + rect.width, xEnd);\r
                stateRect.x = Math.max(rect.x, x);\r
                stateRect.width = Math.max(0, xEnd - stateRect.x + 1);\r
                if (stateRect.x == lastX) {\r
                    stateRect.width -= 1;\r
                    if (stateRect.width > 0) {\r
                        gc.setForeground(Display.getDefault().getSystemColor(SWT.COLOR_BLACK));\r
                        gc.drawPoint(stateRect.x, stateRect.y - 2);\r
                        stateRect.x += 1;\r
                    }\r
                } else {\r
                    lastX = x;\r
                }\r
                boolean timeSelected = selectedTime >= event.getTime() && selectedTime < event.getTime() + event.getDuration();\r
                drawState(_colors, event, stateRect, gc, selected, timeSelected);\r
            }\r
        }\r
        fTimeGraphProvider.postDrawEntry(entry, rect, gc);\r
    }\r
\r
    protected void drawName(Item item, Rectangle bounds, GC gc) {\r
        boolean hasTimeEvents = item._trace.hasTimeEvents();\r
        if (! hasTimeEvents) {\r
            gc.setBackground(_colors.getBkColorGroup(item._selected, _isInFocus));\r
            gc.fillRectangle(bounds);\r
            if (item._selected && _isInFocus) {\r
                gc.setForeground(_colors.getBkColor(item._selected, _isInFocus, false));\r
                gc.drawRectangle(bounds.x, bounds.y, bounds.width - 1, bounds.height - 1);\r
            }\r
        } else {\r
            gc.setBackground(_colors.getBkColor(item._selected, _isInFocus, true));\r
            gc.setForeground(_colors.getFgColor(item._selected, _isInFocus));\r
            gc.fillRectangle(bounds);\r
        }\r
\r
        // No name to be drawn\r
        if (_timeProvider.getNameSpace() == 0) {\r
            return;\r
        }\r
\r
        int leftMargin = MARGIN + item.level * EXPAND_SIZE;\r
        if (item._hasChildren) {\r
            gc.setForeground(_colors.getFgColorGroup(false, false));\r
            gc.setBackground(_colors.getBkColor(false, false, false));\r
            Rectangle rect = Utils.clone(bounds);\r
            rect.x += leftMargin;\r
            rect.y += (bounds.height - EXPAND_SIZE) / 2;\r
            rect.width = EXPAND_SIZE;\r
            rect.height = EXPAND_SIZE;\r
            gc.fillRectangle(rect);\r
            gc.drawRectangle(rect.x, rect.y, rect.width - 1, rect.height - 1);\r
            int midy = rect.y + rect.height / 2;\r
            gc.drawLine(rect.x + 2, midy, rect.x + rect.width - 3, midy);\r
            if (!item._expanded) {\r
                int midx = rect.x + rect.width / 2;\r
                gc.drawLine(midx, rect.y + 2, midx, rect.y + rect.height - 3);\r
            }\r
        }\r
        leftMargin += EXPAND_SIZE + MARGIN;\r
\r
        Image img = fTimeGraphProvider.getItemImage(item._trace);\r
        if (img != null) {\r
            // draw icon\r
            int imgHeight = img.getImageData().height;\r
            int imgWidth = img.getImageData().width;\r
            int x = leftMargin;\r
            int y = bounds.y + (bounds.height - imgHeight) / 2;\r
            gc.drawImage(img, x, y);\r
            leftMargin += imgWidth + MARGIN;\r
        }\r
        String name = item._name;\r
        Point size = gc.stringExtent(name);\r
        if (_idealNameSpace < leftMargin + size.x + MARGIN) {\r
            _idealNameSpace = leftMargin + size.x + MARGIN;\r
        }\r
        if (hasTimeEvents) {\r
            // cut long string with "..."\r
            int width = bounds.width - leftMargin;\r
            int cuts = 0;\r
            while (size.x > width && name.length() > 1) {\r
                cuts++;\r
                name = name.substring(0, name.length() - 1);\r
                size = gc.stringExtent(name + "..."); //$NON-NLS-1$\r
            }\r
            if (cuts > 0) {\r
                name += "..."; //$NON-NLS-1$\r
            }\r
        }\r
        Rectangle rect = Utils.clone(bounds);\r
        rect.x += leftMargin;\r
        rect.width -= leftMargin;\r
        // draw text\r
        if (rect.width > 0) {\r
            rect.y += (bounds.height - gc.stringExtent(name).y) / 2;\r
            gc.setForeground(_colors.getFgColor(item._selected, _isInFocus));\r
            int textWidth = Utils.drawText(gc, name, rect, true);\r
            leftMargin += textWidth + MARGIN;\r
            rect.y -= 2;\r
\r
            if (hasTimeEvents) {\r
                // draw middle line\r
                int x = bounds.x + leftMargin;\r
                int width = bounds.width - x;\r
                int midy = bounds.y + bounds.height / 2;\r
                gc.setForeground(_colors.getColor(TimeGraphColorScheme.MID_LINE));\r
                gc.drawLine(x, midy, x + width, midy);\r
            }\r
        }\r
    }\r
\r
    protected void drawState(TimeGraphColorScheme colors, ITimeEvent event,\r
            Rectangle rect, GC gc, boolean selected, boolean timeSelected) {\r
\r
        int colorIdx = fTimeGraphProvider.getStateTableIndex(event);\r
        if (colorIdx < 0) {\r
            return;\r
        }\r
        boolean visible = rect.width == 0 ? false : true;\r
\r
        if (visible) {\r
            Color stateColor = null;\r
            if (colorIdx < fEventColorMap.length) {\r
                stateColor = fEventColorMap[colorIdx];\r
            } else {\r
                stateColor = Display.getDefault().getSystemColor(SWT.COLOR_BLACK);\r
            }\r
\r
            timeSelected = timeSelected && selected;\r
            if (timeSelected) {\r
                // modify the color?\r
            }\r
            // fill all rect area\r
            gc.setBackground(stateColor);\r
            gc.fillRectangle(rect);\r
            // get the border color?\r
            gc.setForeground(Display.getDefault().getSystemColor(SWT.COLOR_BLACK));\r
\r
            // draw bounds\r
            if (!timeSelected) {\r
                // Draw the top and bottom borders i.e. no side borders\r
                // top\r
                gc.drawLine(rect.x, rect.y, rect.x + rect.width - 1, rect.y);\r
                // bottom\r
                gc.drawLine(rect.x, rect.y + rect.height - 1, rect.x + rect.width - 1, rect.y + rect.height - 1);\r
            }\r
        } else {\r
            gc.setForeground(Display.getDefault().getSystemColor(SWT.COLOR_BLACK));\r
            gc.drawPoint(rect.x, rect.y - 2);\r
            /*\r
            // selected rectangle area is not visible but can be represented\r
            // with a broken vertical line of specified width.\r
            int width = 1;\r
            rect.width = width;\r
            gc.setForeground(stateColor);\r
            int s = gc.getLineStyle();\r
            int w = gc.getLineWidth();\r
            gc.setLineStyle(SWT.LINE_DOT);\r
            gc.setLineWidth(width);\r
            // Trace.debug("Rectangle not visible, drawing vertical line with: "\r
            // + rect.x + "," + rect.y + "," + rect.x + "," + rect.y\r
            // + rect.height);\r
            gc.drawLine(rect.x, rect.y, rect.x, rect.y + rect.height - 1);\r
            gc.setLineStyle(s);\r
            gc.setLineWidth(w);\r
            if (!timeSelected) {\r
                gc.setForeground(Display.getDefault().getSystemColor(SWT.COLOR_BLACK));\r
                gc.drawPoint(rect.x, rect.y);\r
                gc.drawPoint(rect.x, rect.y + rect.height - 1);\r
            }\r
            */\r
        }\r
        fTimeGraphProvider.postDrawEvent(event, rect, gc);\r
    }\r
\r
    protected void fillSpace(Rectangle rect, GC gc, boolean selected) {\r
        gc.setBackground(_colors.getBkColor(selected, _isInFocus, false));\r
        gc.fillRectangle(rect);\r
        // draw middle line\r
        gc.setForeground(_colors.getColor(TimeGraphColorScheme.MID_LINE));\r
        int midy = rect.y + rect.height / 2;\r
        gc.drawLine(rect.x, midy, rect.x + rect.width, midy);\r
    }\r
\r
    @Override\r
    public void keyTraversed(TraverseEvent e) {\r
        if ((e.detail == SWT.TRAVERSE_TAB_NEXT) || (e.detail == SWT.TRAVERSE_TAB_PREVIOUS)) {\r
            e.doit = true;\r
        }\r
    }\r
\r
    @Override\r
    public void keyPressed(KeyEvent e) {\r
        int idx = -1;\r
        if (_data._expandedItems.length == 0) {\r
            return;\r
        }\r
        if (SWT.HOME == e.keyCode) {\r
            idx = 0;\r
        } else if (SWT.END == e.keyCode) {\r
            idx = _data._expandedItems.length - 1;\r
        } else if (SWT.ARROW_DOWN == e.keyCode) {\r
            idx = getSelectedIndex();\r
            if (idx < 0) {\r
                idx = 0;\r
            } else if (idx < _data._expandedItems.length - 1) {\r
                idx++;\r
            }\r
        } else if (SWT.ARROW_UP == e.keyCode) {\r
            idx = getSelectedIndex();\r
            if (idx < 0) {\r
                idx = 0;\r
            } else if (idx > 0) {\r
                idx--;\r
            }\r
        } else if (SWT.ARROW_LEFT == e.keyCode) {\r
            selectPrevEvent();\r
        } else if (SWT.ARROW_RIGHT == e.keyCode) {\r
            selectNextEvent();\r
        } else if (SWT.PAGE_DOWN == e.keyCode) {\r
            int page = countPerPage();\r
            idx = getSelectedIndex();\r
            if (idx < 0) {\r
                idx = 0;\r
            }\r
            idx += page;\r
            if (idx >= _data._expandedItems.length) {\r
                idx = _data._expandedItems.length - 1;\r
            }\r
        } else if (SWT.PAGE_UP == e.keyCode) {\r
            int page = countPerPage();\r
            idx = getSelectedIndex();\r
            if (idx < 0) {\r
                idx = 0;\r
            }\r
            idx -= page;\r
            if (idx < 0) {\r
                idx = 0;\r
            }\r
        } else if (SWT.CR == e.keyCode) {\r
            idx = getSelectedIndex();\r
            if (idx >= 0) {\r
                if (_data._expandedItems[idx]._hasChildren) {\r
                    toggle(idx);\r
                } else {\r
                    fireDefaultSelection();\r
                }\r
            }\r
            idx = -1;\r
        }\r
        if (idx >= 0) {\r
            selectItem(idx, false);\r
            fireSelectionChanged();\r
        }\r
    }\r
\r
    @Override\r
    public void keyReleased(KeyEvent e) {\r
    }\r
\r
    @Override\r
    public void focusGained(FocusEvent e) {\r
        _isInFocus = true;\r
        if (mouseScrollFilterListener == null) {\r
            mouseScrollFilterListener = new Listener() {\r
                // This filter is used to prevent horizontal scrolling of the view\r
                // when the mouse wheel is used to zoom\r
                @Override\r
                public void handleEvent(Event event) {\r
                    event.doit = false;\r
                }\r
            };\r
            getDisplay().addFilter(SWT.MouseWheel, mouseScrollFilterListener);\r
        }\r
        redraw();\r
    }\r
\r
    @Override\r
    public void focusLost(FocusEvent e) {\r
        _isInFocus = false;\r
        if (mouseScrollFilterListener != null) {\r
            getDisplay().removeFilter(SWT.MouseWheel, mouseScrollFilterListener);\r
            mouseScrollFilterListener = null;\r
        }\r
        if (DRAG_NONE != _dragState) {\r
            setCapture(false);\r
            _dragState = DRAG_NONE;\r
        }\r
        redraw();\r
    }\r
\r
    /**\r
     * @return If the current view is focused\r
     */\r
    public boolean isInFocus() {\r
        return _isInFocus;\r
    }\r
\r
    /**\r
     * Provide the possibility to control the wait cursor externally e.g. data\r
     * requests in progress\r
     *\r
     * @param waitInd Should we wait indefinitely?\r
     */\r
    public void waitCursor(boolean waitInd) {\r
        // Update cursor as indicated\r
        if (waitInd) {\r
            setCursor(_WaitCursor);\r
            _isWaitCursor = true;\r
        } else {\r
            setCursor(null);\r
            _isWaitCursor = false;\r
        }\r
\r
        // Get ready for next mouse move\r
        _isDragCursor3 = false;\r
    }\r
\r
    /**\r
     * <p>\r
     * If the x, y position is over the vertical split line (name to time\r
     * ranges), then change the cursor to a drag cursor to indicate the user the\r
     * possibility of resizing\r
     * </p>\r
     *\r
     * @param x\r
     * @param y\r
     */\r
    void updateCursor(int x, int y) {\r
        // if Wait cursor not active, check for the need to change to a drag\r
        // cursor\r
        if (_isWaitCursor == false) {\r
            boolean isSplitLine = isOverSplitLine(x);\r
            // No dragcursor is name space is fixed to zero\r
            if (isSplitLine && !_isDragCursor3 && _timeProvider.getNameSpace() > 0) {\r
                setCursor(_dragCursor3);\r
                _isDragCursor3 = true;\r
            } else if (!isSplitLine && _isDragCursor3) {\r
                setCursor(null);\r
                _isDragCursor3 = false;\r
            }\r
        }\r
    }\r
\r
    @Override\r
    public void mouseMove(MouseEvent e) {\r
        if (null == _timeProvider) {\r
            return;\r
        }\r
        Point size = getCtrlSize();\r
        if (DRAG_TRACE_ITEM == _dragState) {\r
            int nameWidth = _timeProvider.getNameSpace();\r
            int x = e.x - nameWidth;\r
            if (x > 0 && size.x > nameWidth && _dragX != x) {\r
                _dragX = x;\r
                double pixelsPerNanoSec = (size.x - nameWidth <= RIGHT_MARGIN) ? 0 : (double) (size.x - nameWidth - RIGHT_MARGIN) / (_time1bak - _time0bak);\r
                long timeDelta = (long) ((pixelsPerNanoSec == 0) ? 0 : ((_dragX - _dragX0) / pixelsPerNanoSec));\r
                long time1 = _time1bak - timeDelta;\r
                long maxTime = _timeProvider.getMaxTime();\r
                if (time1 > maxTime) {\r
                    time1 = maxTime;\r
                }\r
                long time0 = time1 - (_time1bak - _time0bak);\r
                if (time0 < _timeProvider.getMinTime()) {\r
                    time0 = _timeProvider.getMinTime();\r
                    time1 = time0 + (_time1bak - _time0bak);\r
                }\r
                _timeProvider.setStartFinishTime(time0, time1);\r
            }\r
        } else if (DRAG_SPLIT_LINE == _dragState) {\r
            _dragX = e.x;\r
            _timeProvider.setNameSpace(e.x);\r
        } else if (DRAG_NONE == _dragState) {\r
            boolean mouseOverSplitLine = isOverSplitLine(e.x);\r
            if (_mouseOverSplitLine != mouseOverSplitLine) {\r
                redraw();\r
            }\r
            _mouseOverSplitLine = mouseOverSplitLine;\r
        }\r
        updateCursor(e.x, e.y);\r
    }\r
\r
    @Override\r
    public void mouseDoubleClick(MouseEvent e) {\r
        if (null == _timeProvider) {\r
            return;\r
        }\r
        if (1 == e.button) {\r
            if (isOverSplitLine(e.x) && _timeProvider.getNameSpace() != 0) {\r
                _timeProvider.setNameSpace(_idealNameSpace);\r
                boolean mouseOverSplitLine = isOverSplitLine(e.x);\r
                if (_mouseOverSplitLine != mouseOverSplitLine) {\r
                    redraw();\r
                }\r
                _mouseOverSplitLine = mouseOverSplitLine;\r
                return;\r
            }\r
            int idx = getItemIndexAtY(e.y);\r
            if (idx >= 0) {\r
                selectItem(idx, false);\r
                fireDefaultSelection();\r
            }\r
        }\r
    }\r
\r
    @Override\r
    public void mouseDown(MouseEvent e) {\r
        if (null == _timeProvider) {\r
            return;\r
        }\r
        int idx;\r
        if (1 == e.button) {\r
            int nameSpace = _timeProvider.getNameSpace();\r
            if (nameSpace != 0) {\r
                if (isOverSplitLine(e.x)) {\r
                    _dragState = DRAG_SPLIT_LINE;\r
                    _dragX = _dragX0 = e.x;\r
                    _time0bak = _timeProvider.getTime0();\r
                    _time1bak = _timeProvider.getTime1();\r
                    redraw();\r
                    return;\r
                }\r
            }\r
\r
            idx = getItemIndexAtY(e.y);\r
            if (idx >= 0) {\r
                Item item = _data._expandedItems[idx];\r
                if (item._hasChildren && e.x < nameSpace && e.x < MARGIN + (item.level + 1) * EXPAND_SIZE) {\r
                    toggle(idx);\r
                } else {\r
                    long hitTime = getTimeAtX(e.x);\r
                    if (hitTime >= 0) {\r
                        // _timeProvider.setSelectedTimeInt(hitTime, false);\r
                        setCapture(true);\r
                        _dragState = DRAG_TRACE_ITEM;\r
                        _dragX = _dragX0 = e.x - nameSpace;\r
                        _time0bak = _timeProvider.getTime0();\r
                        _time1bak = _timeProvider.getTime1();\r
                    }\r
                }\r
                selectItem(idx, false);\r
                fireSelectionChanged();\r
            } else {\r
                selectItem(idx, false); // clear selection\r
                redraw();\r
                fireSelectionChanged();\r
            }\r
        }\r
    }\r
\r
    @Override\r
    public void mouseUp(MouseEvent e) {\r
        if (DRAG_NONE != _dragState) {\r
            setCapture(false);\r
            if (DRAG_TRACE_ITEM == _dragState) {\r
                // Notify time provider to check the need for listener\r
                // notification\r
                _timeProvider.notifyStartFinishTime();\r
                if (_dragX == _dragX0) { // click without drag\r
                    long time = getTimeAtX(e.x);\r
                    _timeProvider.setSelectedTimeNotify(time, false);\r
                }\r
            } else if (DRAG_SPLIT_LINE == _dragState) {\r
                redraw();\r
            }\r
            _dragState = DRAG_NONE;\r
        }\r
    }\r
\r
    @Override\r
    public void mouseEnter(MouseEvent e) {\r
    }\r
\r
    @Override\r
    public void mouseExit(MouseEvent e) {\r
        if (_mouseOverSplitLine) {\r
            _mouseOverSplitLine = false;\r
            redraw();\r
        }\r
    }\r
\r
    @Override\r
    public void mouseHover(MouseEvent e) {\r
    }\r
\r
    @Override\r
    public void mouseScrolled(MouseEvent e) {\r
        if ((mouseScrollFilterListener == null) || _dragState != DRAG_NONE) {\r
            return;\r
        }\r
        boolean zoomScroll = false;\r
        Point p = getParent().toControl(getDisplay().getCursorLocation());\r
        Point parentSize = getParent().getSize();\r
        if (p.x >= 0 && p.x < parentSize.x && p.y >= 0 && p.y < parentSize.y) {\r
            // over the parent control\r
            if (e.x > getCtrlSize().x) {\r
                // over the horizontal scroll bar\r
                zoomScroll = false;\r
            } else if (e.y >= 0 && e.y < getCtrlSize().y && e.x < _timeProvider.getNameSpace()) {\r
                // over the name space\r
                zoomScroll = false;\r
            } else {\r
                zoomScroll = true;\r
            }\r
        }\r
        if (zoomScroll && _timeProvider.getTime0() != _timeProvider.getTime1()) {\r
            if (e.count > 0) {\r
                zoom(true);\r
            } else if (e.count < 0) {\r
                zoom(false);\r
            }\r
        } else {\r
            setTopIndex(getTopIndex() - e.count);\r
        }\r
    }\r
\r
    @Override\r
    public void controlMoved(ControlEvent e) {\r
    }\r
\r
    @Override\r
    public void controlResized(ControlEvent e) {\r
        adjustScrolls();\r
    }\r
\r
    @Override\r
    public void widgetDefaultSelected(SelectionEvent e) {\r
    }\r
\r
    @Override\r
    public void widgetSelected(SelectionEvent e) {\r
        if (e.widget == getVerticalBar()) {\r
            setTopIndex(getVerticalBar().getSelection());\r
        } else if (e.widget == getHorizontalBar() && null != _timeProvider) {\r
            int start = getHorizontalBar().getSelection();\r
            long time0 = _timeProvider.getTime0();\r
            long time1 = _timeProvider.getTime1();\r
            long timeMin = _timeProvider.getMinTime();\r
            long timeMax = _timeProvider.getMaxTime();\r
            long delta = timeMax - timeMin;\r
\r
            long range = time1 - time0;\r
            // _timeRangeFixed = true;\r
            time0 = timeMin + Math.round(delta * ((double) start / H_SCROLLBAR_MAX));\r
            time1 = time0 + range;\r
\r
            // TODO: Follow-up with Bug 310310\r
            // In Linux SWT.DRAG is the only value received\r
            // https://bugs.eclipse.org/bugs/show_bug.cgi?id=310310\r
            if (e.detail == SWT.DRAG) {\r
                _timeProvider.setStartFinishTime(time0, time1);\r
            } else {\r
                _timeProvider.setStartFinishTimeNotify(time0, time1);\r
            }\r
        }\r
    }\r
\r
    /**\r
     * @return The current visibility of the vertical scroll bar\r
     */\r
    public boolean isVisibleVerticalScroll() {\r
        return _visibleVerticalScroll;\r
    }\r
\r
    @Override\r
    public int getBorderWidth() {\r
        return _borderWidth;\r
    }\r
\r
    /**\r
     * Set the border width\r
     *\r
     * @param borderWidth\r
     *            The width\r
     */\r
    public void setBorderWidth(int borderWidth) {\r
        this._borderWidth = borderWidth;\r
    }\r
\r
    /**\r
     * @return The current height of the header row\r
     */\r
    public int getHeaderHeight() {\r
        return _headerHeight;\r
    }\r
\r
    /**\r
     * Set the height of the header row\r
     *\r
     * @param headerHeight\r
     *            The height\r
     */\r
    public void setHeaderHeight(int headerHeight) {\r
        this._headerHeight = headerHeight;\r
    }\r
\r
    /**\r
     * @return The height of regular item rows\r
     */\r
    public int getItemHeight() {\r
        return _itemHeight;\r
    }\r
\r
    /**\r
     * Set the height of regular itew rows\r
     *\r
     * @param rowHeight\r
     *            The height\r
     */\r
    public void setItemHeight(int rowHeight) {\r
        this._itemHeight = rowHeight;\r
    }\r
\r
    /**\r
     * Set the minimum item width\r
     *\r
     * @param width The minimum width\r
     */\r
    public void setMinimumItemWidth(int width) {\r
        this._minimumItemWidth = width;\r
    }\r
\r
    /**\r
     * @return The minimum item width\r
     */\r
    public int getMinimumItemWidth() {\r
        return _minimumItemWidth;\r
    }\r
\r
    /**\r
     * @return The entries that are currently filtered out\r
     */\r
    public Vector<ITimeGraphEntry> getFilteredOut() {\r
        return _data.getFilteredOut();\r
    }\r
\r
    // @Override\r
    @Override\r
    public void addSelectionChangedListener(ISelectionChangedListener listener) {\r
        if (listener != null) {\r
            if (!_selectionChangedListeners.contains(listener)) {\r
                _selectionChangedListeners.add(listener);\r
            }\r
        }\r
    }\r
\r
    // @Override\r
    @Override\r
    public void removeSelectionChangedListener(ISelectionChangedListener listener) {\r
        if (listener != null) {\r
            _selectionChangedListeners.remove(listener);\r
        }\r
    }\r
\r
    // @Override\r
    @Override\r
    public void setSelection(ISelection selection) {\r
        if (selection instanceof TimeGraphSelection) {\r
            TimeGraphSelection sel = (TimeGraphSelection) selection;\r
            Object ob = sel.getFirstElement();\r
            if (ob instanceof ITimeGraphEntry) {\r
                ITimeGraphEntry trace = (ITimeGraphEntry) ob;\r
                selectItem(trace, false);\r
            }\r
        }\r
\r
    }\r
\r
    private class ItemData {\r
        public Item[] _expandedItems = new Item[0];\r
        public Item[] _items = new Item[0];\r
        private ITimeGraphEntry _traces[] = new ITimeGraphEntry[0];\r
        private boolean traceFilter[] = new boolean[0];\r
        private final Vector<ITimeGraphEntry> filteredOut = new Vector<ITimeGraphEntry>();\r
        public ITimeGraphPresentationProvider provider;\r
\r
        public ItemData() {\r
        }\r
\r
        Item findItem(ITimeGraphEntry entry) {\r
            if (entry == null) {\r
                return null;\r
            }\r
\r
            for (int i = 0; i < _items.length; i++) {\r
                Item item = _items[i];\r
                if (item._trace == entry) {\r
                    return item;\r
                }\r
            }\r
\r
            return null;\r
        }\r
\r
        int findItemIndex(ITimeGraphEntry trace) {\r
            if (trace == null) {\r
                return -1;\r
            }\r
\r
            for (int i = 0; i < _expandedItems.length; i++) {\r
                Item item = _expandedItems[i];\r
                if (item._trace == trace) {\r
                    return i;\r
                }\r
            }\r
\r
            return -1;\r
        }\r
\r
        public void refreshData() {\r
            List<Item> itemList = new ArrayList<Item>();\r
            filteredOut.clear();\r
            for (int i = 0; i < _traces.length; i++) {\r
                ITimeGraphEntry entry = _traces[i];\r
                refreshData(itemList, null, 0, entry);\r
            }\r
            _items = itemList.toArray(new Item[0]);\r
            updateExpandedItems();\r
        }\r
\r
        private void refreshData(List<Item> itemList, Item parent, int level, ITimeGraphEntry entry) {\r
            Item item = new Item(entry, entry.getName(), level);\r
            if (parent != null) {\r
                parent.children.add(item);\r
            }\r
            item.itemHeight = provider.getItemHeight(entry);\r
            itemList.add(item);\r
            if (entry.hasChildren()) {\r
                item._expanded = true;\r
                item._hasChildren = true;\r
                for (ITimeGraphEntry child : entry.getChildren()) {\r
                    refreshData(itemList, item, level + 1, child);\r
                }\r
            }\r
        }\r
\r
        public void updateExpandedItems() {\r
            List<Item> expandedItemList = new ArrayList<Item>();\r
            for (int i = 0; i < _traces.length; i++) {\r
                ITimeGraphEntry entry = _traces[i];\r
                Item item = findItem(entry);\r
                refreshExpanded(expandedItemList, item);\r
            }\r
            _expandedItems = expandedItemList.toArray(new Item[0]);\r
        }\r
\r
        private void refreshExpanded(List<Item> expandedItemList, Item item) {\r
            expandedItemList.add(item);\r
            if (item._hasChildren && item._expanded) {\r
                for (Item child : item.children) {\r
                    refreshExpanded(expandedItemList, child);\r
                }\r
            }\r
        }\r
\r
        public void refreshData(ITimeGraphEntry traces[]) {\r
            if (traces == null || traces.length == 0) {\r
                traceFilter = null;\r
            } else if (traceFilter == null || traces.length != traceFilter.length) {\r
                traceFilter = new boolean[traces.length];\r
                java.util.Arrays.fill(traceFilter, true);\r
            }\r
\r
            _traces = traces;\r
            refreshData();\r
        }\r
\r
        public ITimeGraphEntry[] getTraces() {\r
            return _traces;\r
        }\r
\r
        public boolean[] getTraceFilter() {\r
            return traceFilter;\r
        }\r
\r
        public Vector<ITimeGraphEntry> getFilteredOut() {\r
            return filteredOut;\r
        }\r
    }\r
\r
    private class Item {\r
        public boolean _expanded;\r
        public boolean _selected;\r
        public boolean _hasChildren;\r
        public int itemHeight;\r
        public int level;\r
        public List<Item> children;\r
        public String _name;\r
        public ITimeGraphEntry _trace;\r
\r
        public Item(ITimeGraphEntry trace, String name, int level) {\r
            this._trace = trace;\r
            this._name = name;\r
            this.level = level;\r
            this.children = new ArrayList<Item>();\r
        }\r
\r
        @Override\r
        public String toString() {\r
            return _name;\r
        }\r
    }\r
\r
}\r
\r