[deliverable/tracecompass.git] / org.eclipse.linuxtools.lttng2.kernel.ui / src / org / eclipse / linuxtools / internal / lttng2 / kernel / ui / views / resources / ResourcesView.java

/*******************************************************************************\r
 * Copyright (c) 2012 Ericsson\r
 * \r
 * All rights reserved. This program and the accompanying materials are\r
 * made available under the terms of the Eclipse Public License v1.0 which\r
 * accompanies this distribution, and is available at\r
 * http://www.eclipse.org/legal/epl-v10.html\r
 * \r
 * Contributors:\r
 *   Patrick Tasse - Initial API and implementation\r
 *******************************************************************************/\r
\r
package org.eclipse.linuxtools.internal.lttng2.kernel.ui.views.resources;\r
\r
import java.util.ArrayList;\r
import java.util.Arrays;\r
import java.util.HashMap;\r
import java.util.Iterator;\r
import java.util.List;\r
import java.util.Map;\r
\r
import org.eclipse.jface.action.Action;\r
import org.eclipse.jface.action.IToolBarManager;\r
import org.eclipse.jface.action.Separator;\r
import org.eclipse.linuxtools.internal.lttng2.kernel.ui.Messages;\r
import org.eclipse.linuxtools.internal.lttng2.kernel.ui.views.resources.ResourcesEntry.Type;\r
import org.eclipse.linuxtools.lttng2.kernel.core.trace.Attributes;\r
import org.eclipse.linuxtools.lttng2.kernel.core.trace.CtfKernelTrace;\r
import org.eclipse.linuxtools.tmf.core.ctfadaptor.CtfTmfTimestamp;\r
import org.eclipse.linuxtools.tmf.core.event.ITmfEvent;\r
import org.eclipse.linuxtools.tmf.core.event.TmfEvent;\r
import org.eclipse.linuxtools.tmf.core.event.TmfTimeRange;\r
import org.eclipse.linuxtools.tmf.core.event.TmfTimestamp;\r
import org.eclipse.linuxtools.tmf.core.exceptions.AttributeNotFoundException;\r
import org.eclipse.linuxtools.tmf.core.exceptions.StateValueTypeException;\r
import org.eclipse.linuxtools.tmf.core.exceptions.TimeRangeException;\r
import org.eclipse.linuxtools.tmf.core.interval.ITmfStateInterval;\r
import org.eclipse.linuxtools.tmf.core.signal.TmfExperimentSelectedSignal;\r
import org.eclipse.linuxtools.tmf.core.signal.TmfRangeSynchSignal;\r
import org.eclipse.linuxtools.tmf.core.signal.TmfSignalHandler;\r
import org.eclipse.linuxtools.tmf.core.signal.TmfTimeSynchSignal;\r
import org.eclipse.linuxtools.tmf.core.statesystem.IStateSystemQuerier;\r
import org.eclipse.linuxtools.tmf.core.trace.ITmfTrace;\r
import org.eclipse.linuxtools.tmf.core.trace.TmfExperiment;\r
import org.eclipse.linuxtools.tmf.ui.views.TmfView;\r
import org.eclipse.linuxtools.tmf.ui.widgets.timegraph.ITimeGraphRangeListener;\r
import org.eclipse.linuxtools.tmf.ui.widgets.timegraph.ITimeGraphTimeListener;\r
import org.eclipse.linuxtools.tmf.ui.widgets.timegraph.StateItem;\r
import org.eclipse.linuxtools.tmf.ui.widgets.timegraph.TimeGraphPresentationProvider;\r
import org.eclipse.linuxtools.tmf.ui.widgets.timegraph.TimeGraphRangeUpdateEvent;\r
import org.eclipse.linuxtools.tmf.ui.widgets.timegraph.TimeGraphTimeEvent;\r
import org.eclipse.linuxtools.tmf.ui.widgets.timegraph.TimeGraphViewer;\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.linuxtools.tmf.ui.widgets.timegraph.model.TimeEvent;\r
import org.eclipse.swt.SWT;\r
import org.eclipse.swt.graphics.RGB;\r
import org.eclipse.swt.widgets.Composite;\r
import org.eclipse.swt.widgets.Display;\r
import org.eclipse.ui.IActionBars;\r
\r
public class ResourcesView extends TmfView {\r
\r
    // ------------------------------------------------------------------------\r
    // Constants\r
    // ------------------------------------------------------------------------\r
\r
    /**\r
     * View ID.\r
     */\r
    public static final String ID = "org.eclipse.linuxtools.lttng2.kernel.ui.views.resources"; //$NON-NLS-1$\r
\r
    /**\r
     * Initial time range\r
     */\r
    private static final long INITIAL_WINDOW_OFFSET = (1L * 100  * 1000 * 1000); // .1sec\r
    \r
    // ------------------------------------------------------------------------\r
    // Fields\r
    // ------------------------------------------------------------------------\r
\r
    // The time graph viewer\r
    TimeGraphViewer fTimeGraphViewer;\r
\r
    // The selected experiment\r
    private TmfExperiment<ITmfEvent> fSelectedExperiment;\r
\r
    // The time graph entry list\r
    private ArrayList<TraceEntry> fEntryList;\r
\r
    // The start time\r
    private long fStartTime;\r
\r
    // The end time\r
    private long fEndTime;\r
\r
    // The display width\r
    private int fDisplayWidth;\r
    \r
    // The next resource action\r
    private Action fNextResourceAction;\r
    \r
    // The previous resource action\r
    private Action fPreviousResourceAction;\r
\r
    // The zoom thread\r
    private ZoomThread fZoomThread;\r
\r
    // ------------------------------------------------------------------------\r
    // Classes\r
    // ------------------------------------------------------------------------\r
\r
    private class TraceEntry implements ITimeGraphEntry {\r
        private CtfKernelTrace fTrace;\r
        public ArrayList<ResourcesEntry> fChildren;\r
        public String fName;\r
\r
        public TraceEntry(CtfKernelTrace trace, String name) {\r
            fTrace = trace;\r
            fChildren = new ArrayList<ResourcesEntry>();\r
            fName = name;\r
        }\r
\r
        @Override\r
        public ITimeGraphEntry getParent() {\r
            return null;\r
        }\r
\r
        @Override\r
        public boolean hasChildren() {\r
            return fChildren != null && fChildren.size() > 0;\r
        }\r
\r
        @Override\r
        public ResourcesEntry[] getChildren() {\r
            return fChildren.toArray(new ResourcesEntry[0]);\r
        }\r
\r
        @Override\r
        public String getName() {\r
            return fName;\r
        }\r
\r
        @Override\r
        public long getStartTime() {\r
            return -1;\r
        }\r
\r
        @Override\r
        public long getEndTime() {\r
            return -1;\r
        }\r
\r
        @Override\r
        public Iterator<ITimeEvent> getTimeEventsIterator() {\r
            return null;\r
        }\r
\r
        @Override\r
        public <T extends ITimeEvent> Iterator<T> getTimeEventsIterator(long startTime, long stopTime, long visibleDuration) {\r
            return null;\r
        }\r
\r
        public CtfKernelTrace getTrace() {\r
            return fTrace;\r
        }\r
\r
        public void addChild(ResourcesEntry entry) {\r
            int index;\r
            for (index = 0; index < fChildren.size(); index++) {\r
                ResourcesEntry other = fChildren.get(index);\r
                if (entry.getType().compareTo(other.getType()) < 0) {\r
                    break;\r
                } else if (entry.getType().equals(other.getType())) {\r
                    if (entry.getId() < other.getId()) {\r
                        break;\r
                    }\r
                }\r
            }\r
            entry.setParent(this);\r
            fChildren.add(index, entry);\r
        }\r
    }\r
\r
    private class ZoomThread extends Thread {\r
        private long fZoomStartTime;\r
        private long fZoomEndTime;\r
        private boolean fCancelled = false;\r
\r
        public ZoomThread(long startTime, long endTime) {\r
            super("ResourcesView zoom"); //$NON-NLS-1$\r
            fZoomStartTime = startTime;\r
            fZoomEndTime = endTime;\r
        }\r
\r
        @Override\r
        public void run() {\r
            if (fEntryList == null) {\r
                return;\r
            }\r
            long resolution = Math.max(1, (fZoomEndTime - fZoomStartTime) / fDisplayWidth);\r
            for (TraceEntry traceEntry : fEntryList) {\r
                for (ITimeGraphEntry child : traceEntry.getChildren()) {\r
                    ResourcesEntry entry = (ResourcesEntry) child;\r
                    if (fCancelled) {\r
                        break;\r
                    }\r
                    List<ITimeEvent> zoomedEventList = getEventList(entry, fZoomStartTime, fZoomEndTime, resolution, true);\r
                    entry.setZoomedEventList(zoomedEventList);\r
                    redraw();\r
                }\r
            }\r
        }\r
\r
        public void cancel() {\r
            fCancelled = true;\r
        }\r
    }\r
\r
    // ------------------------------------------------------------------------\r
    // Constructors\r
    // ------------------------------------------------------------------------\r
\r
    public ResourcesView() {\r
        super(ID);\r
        fDisplayWidth = Display.getDefault().getBounds().width;\r
    }\r
\r
    // ------------------------------------------------------------------------\r
    // ViewPart\r
    // ------------------------------------------------------------------------\r
\r
    /* (non-Javadoc)\r
     * @see org.eclipse.linuxtools.tmf.ui.views.TmfView#createPartControl(org.eclipse.swt.widgets.Composite)\r
     */\r
    @Override\r
    public void createPartControl(Composite parent) {\r
        fTimeGraphViewer = new TimeGraphViewer(parent, SWT.NONE);\r
\r
        fTimeGraphViewer.setTimeGraphProvider(new TimeGraphPresentationProvider() {\r
            private static final String UNKNOWN = "UNKNOWN"; //$NON-NLS-1$\r
            private static final String IDLE = "IDLE"; //$NON-NLS-1$\r
            private static final String BUSY = "BUSY"; //$NON-NLS-1$\r
            private static final String INTERRUPTED = "INTERRUPTED"; //$NON-NLS-1$\r
            private static final String RAISED = "RAISED"; //$NON-NLS-1$\r
            private static final String ACTIVE = "ACTIVE"; //$NON-NLS-1$\r
\r
            @Override \r
            public String getStateTypeName() {\r
                return Messages.ResourcesView_stateTypeName;\r
            }\r
            \r
            @Override\r
            public String getEventName(ITimeEvent event) {\r
                if (event instanceof ResourcesEvent) {\r
                    ResourcesEvent resourcesEvent = (ResourcesEvent) event;\r
                    if (resourcesEvent.getType() == Type.CPU) {\r
                        int currentThread = resourcesEvent.getValue();\r
                        if (currentThread == 0) {\r
                            return IDLE;\r
                        } else {\r
                            return BUSY;\r
                        }\r
                    } else if (resourcesEvent.getType() == Type.IRQ || resourcesEvent.getType() == Type.SOFT_IRQ) {\r
                        int cpu = resourcesEvent.getValue();\r
                        if (cpu == Attributes.SOFT_IRQ_RAISED) {\r
                            return RAISED;\r
                        }\r
                        return ACTIVE;\r
                    } else {\r
                        return null;\r
                    }\r
                }\r
                return UNKNOWN;\r
            }\r
            \r
            @Override\r
            public Map<String, String> getEventHoverToolTipInfo(ITimeEvent event) {\r
                return new HashMap<String, String>();\r
            }\r
            \r
            @Override\r
            public StateItem[] getStateTable() {\r
                return new StateItem[] {\r
                        new StateItem(new RGB(100, 100, 100), UNKNOWN),\r
                        new StateItem(new RGB(200, 200, 200), IDLE),\r
                        new StateItem(new RGB(0, 200, 0), BUSY),\r
                        new StateItem(new RGB(200, 100, 100), INTERRUPTED),\r
                        new StateItem(new RGB(200, 200, 0), RAISED),\r
                        new StateItem(new RGB(200, 150, 100), ACTIVE)\r
                };\r
            }\r
\r
            @Override\r
            public int getEventTableIndex(ITimeEvent event) {\r
                if (event instanceof ResourcesEvent) {\r
                    ResourcesEvent resourcesEvent = (ResourcesEvent) event;\r
                    if (resourcesEvent.getType() == Type.CPU) {\r
                        int currentThread = resourcesEvent.getValue();\r
                        if (currentThread == 0) {\r
                            return 1; // IDLE\r
                        } else {\r
                            return 2; // BUSY\r
                        }\r
                    } else if (resourcesEvent.getType() == Type.IRQ || resourcesEvent.getType() == Type.SOFT_IRQ) {\r
                        int cpu = resourcesEvent.getValue();\r
                        if (cpu == Attributes.SOFT_IRQ_RAISED) {\r
                            return 4; // RAISED\r
                        }\r
                        return 5; // ACTIVE\r
                    } else {\r
                        return -1; // NULL\r
                    }\r
                }\r
                return 0; // UNKNOWN\r
            }\r
        });\r
\r
        fTimeGraphViewer.setTimeCalendarFormat(true);\r
\r
        fTimeGraphViewer.addRangeListener(new ITimeGraphRangeListener() {\r
            @Override\r
            public void timeRangeUpdated(TimeGraphRangeUpdateEvent event) {\r
                long startTime = event.getStartTime();\r
                long endTime = event.getEndTime();\r
                TmfTimeRange range = new TmfTimeRange(new CtfTmfTimestamp(startTime), new CtfTmfTimestamp(endTime));\r
                TmfTimestamp time = new CtfTmfTimestamp(fTimeGraphViewer.getSelectedTime());\r
                broadcast(new TmfRangeSynchSignal(ResourcesView.this, range, time));\r
                startZoomThread(startTime, endTime);\r
            }\r
        });\r
\r
        fTimeGraphViewer.addTimeListener(new ITimeGraphTimeListener() {\r
            @Override\r
            public void timeSelected(TimeGraphTimeEvent event) {\r
                long time = event.getTime();\r
                broadcast(new TmfTimeSynchSignal(ResourcesView.this, new CtfTmfTimestamp(time)));\r
            }\r
        });\r
\r
        final Thread thread = new Thread("ResourcesView build") { //$NON-NLS-1$\r
            @Override\r
            public void run() {\r
                if (TmfExperiment.getCurrentExperiment() != null) {\r
                    selectExperiment(TmfExperiment.getCurrentExperiment());\r
                }\r
            }\r
        };\r
        thread.start();\r
        \r
        // View Action Handling\r
        makeActions();\r
        contributeToActionBars();\r
    }\r
\r
    /* (non-Javadoc)\r
     * @see org.eclipse.ui.part.WorkbenchPart#setFocus()\r
     */\r
    @Override\r
    public void setFocus() {\r
        fTimeGraphViewer.setFocus();\r
    }\r
\r
    // ------------------------------------------------------------------------\r
    // Signal handlers\r
    // ------------------------------------------------------------------------\r
\r
    @TmfSignalHandler\r
    public void experimentSelected(final TmfExperimentSelectedSignal<? extends TmfEvent> signal) {\r
        if (signal.getExperiment().equals(fSelectedExperiment)) {\r
            return;\r
        }\r
\r
        final Thread thread = new Thread("ResourcesView build") { //$NON-NLS-1$\r
            @Override\r
            public void run() {\r
                selectExperiment(signal.getExperiment());\r
            }};\r
        thread.start();\r
    }\r
\r
    @TmfSignalHandler\r
    public void synchToTime(final TmfTimeSynchSignal signal) {\r
        if (signal.getSource() == this) {\r
            return;\r
        }\r
        final long time = signal.getCurrentTime().normalize(0, -9).getValue();\r
        Display.getDefault().asyncExec(new Runnable() {\r
            @Override\r
            public void run() {\r
                if (fTimeGraphViewer.getControl().isDisposed()) {\r
                    return;\r
                }\r
                fTimeGraphViewer.setSelectedTime(time, true);\r
            }\r
        });\r
    }\r
\r
    @TmfSignalHandler\r
    public void synchToRange(final TmfRangeSynchSignal signal) {\r
        if (signal.getSource() == this) {\r
            return;\r
        }\r
        final long startTime = signal.getCurrentRange().getStartTime().normalize(0, -9).getValue();\r
        final long endTime = signal.getCurrentRange().getEndTime().normalize(0, -9).getValue();\r
        final long time = signal.getCurrentTime().normalize(0, -9).getValue();\r
        Display.getDefault().asyncExec(new Runnable() {\r
            @Override\r
            public void run() {\r
                if (fTimeGraphViewer.getControl().isDisposed()) {\r
                    return;\r
                }\r
                fTimeGraphViewer.setStartFinishTime(startTime, endTime);\r
                fTimeGraphViewer.setSelectedTime(time, true);\r
                startZoomThread(startTime, endTime);\r
            }\r
        });\r
    }\r
\r
    // ------------------------------------------------------------------------\r
    // Internal\r
    // ------------------------------------------------------------------------\r
\r
    @SuppressWarnings("unchecked")\r
    private void selectExperiment(TmfExperiment<?> experiment) {\r
        fStartTime = Long.MAX_VALUE;\r
        fEndTime = Long.MIN_VALUE;\r
        fSelectedExperiment = (TmfExperiment<ITmfEvent>) experiment;\r
        fEntryList = new ArrayList<TraceEntry>();\r
        for (ITmfTrace<?> trace : experiment.getTraces()) {\r
            if (trace instanceof CtfKernelTrace) {\r
                CtfKernelTrace ctfKernelTrace = (CtfKernelTrace) trace;\r
                TraceEntry groupEntry = new TraceEntry(ctfKernelTrace, trace.getName());\r
                fEntryList.add(groupEntry);\r
                IStateSystemQuerier ssq = ctfKernelTrace.getStateSystem();\r
                long startTime = ssq.getStartTime();\r
                long endTime = ssq.getCurrentEndTime() + 1;\r
                fStartTime = Math.min(fStartTime, startTime);\r
                fEndTime = Math.max(fEndTime, endTime);\r
                List<Integer> cpuQuarks = ssq.getQuarks(Attributes.CPUS, "*"); //$NON-NLS-1$\r
                ResourcesEntry[] cpuEntries = new ResourcesEntry[cpuQuarks.size()];\r
                for (int i = 0; i < cpuQuarks.size(); i++) {\r
                    int cpuQuark = cpuQuarks.get(i);\r
                    int cpu = Integer.parseInt(ssq.getAttributeName(cpuQuark));\r
                    ResourcesEntry entry = new ResourcesEntry(cpuQuark, ctfKernelTrace, Type.CPU, cpu);\r
                    groupEntry.addChild(entry);\r
                    cpuEntries[i] = entry;\r
                }\r
                List<Integer> irqQuarks = ssq.getQuarks(Attributes.RESOURCES, Attributes.IRQS, "*"); //$NON-NLS-1$\r
                ResourcesEntry[] irqEntries = new ResourcesEntry[irqQuarks.size()];\r
                for (int i = 0; i < irqQuarks.size(); i++) {\r
                    int irqQuark = irqQuarks.get(i);\r
                    int irq = Integer.parseInt(ssq.getAttributeName(irqQuark));\r
                    ResourcesEntry entry = new ResourcesEntry(irqQuark, ctfKernelTrace, Type.IRQ, irq);\r
                    groupEntry.addChild(entry);\r
                    irqEntries[i] = entry;\r
                }\r
                List<Integer> softIrqQuarks = ssq.getQuarks(Attributes.RESOURCES, Attributes.SOFT_IRQS, "*"); //$NON-NLS-1$\r
                ResourcesEntry[] softIrqEntries = new ResourcesEntry[softIrqQuarks.size()];\r
                for (int i = 0; i < softIrqQuarks.size(); i++) {\r
                    int softIrqQuark = softIrqQuarks.get(i);\r
                    int softIrq = Integer.parseInt(ssq.getAttributeName(softIrqQuark));\r
                    ResourcesEntry entry = new ResourcesEntry(softIrqQuark, ctfKernelTrace, Type.SOFT_IRQ, softIrq);\r
                    groupEntry.addChild(entry);\r
                    softIrqEntries[i] = entry;\r
                }\r
            }\r
        }\r
        refresh(INITIAL_WINDOW_OFFSET);\r
        for (TraceEntry traceEntry : fEntryList) {\r
            CtfKernelTrace ctfKernelTrace = ((TraceEntry) traceEntry).getTrace();\r
            IStateSystemQuerier ssq = ctfKernelTrace.getStateSystem();\r
            long startTime = ssq.getStartTime();\r
            long endTime = ssq.getCurrentEndTime() + 1;\r
            long resolution = (endTime - startTime) / fDisplayWidth;\r
            for (ResourcesEntry entry : traceEntry.getChildren()) {\r
                List<ITimeEvent> eventList = getEventList(entry, startTime, endTime, resolution, false);\r
                entry.setEventList(eventList);\r
                redraw();\r
            }\r
        }\r
    }\r
\r
    private List<ITimeEvent> getEventList(ResourcesEntry entry, long startTime, long endTime, long resolution, boolean includeNull) {\r
        IStateSystemQuerier ssq = entry.getTrace().getStateSystem();\r
        List<ITimeEvent> eventList = null;\r
        int quark = entry.getQuark();\r
        try {\r
            if (entry.getType().equals(Type.CPU)) {\r
                int currentThreadQuark = ssq.getQuarkRelative(quark, Attributes.CURRENT_THREAD);\r
                List<ITmfStateInterval> currentThreadIntervals = ssq.queryHistoryRange(currentThreadQuark, startTime, endTime - 1, resolution);\r
                eventList = new ArrayList<ITimeEvent>(currentThreadIntervals.size());\r
                long lastEndTime = -1;\r
                for (ITmfStateInterval currentThreadInterval : currentThreadIntervals) {\r
                    if (!currentThreadInterval.getStateValue().isNull()) {\r
                        int currentThread = currentThreadInterval.getStateValue().unboxInt();\r
                        long time = currentThreadInterval.getStartTime();\r
                        long duration = currentThreadInterval.getEndTime() - time + 1;\r
                        if (lastEndTime != time && lastEndTime != -1) {\r
                            eventList.add(new TimeEvent(entry, lastEndTime, time - lastEndTime));\r
                        }\r
                        eventList.add(new ResourcesEvent(entry, time, duration, currentThread));\r
                        lastEndTime = time + duration;\r
                    }\r
                }\r
            } else if (entry.getType().equals(Type.IRQ)) {\r
                List<ITmfStateInterval> irqIntervals = ssq.queryHistoryRange(quark, startTime, endTime - 1, resolution);\r
                eventList = new ArrayList<ITimeEvent>(irqIntervals.size());\r
                long lastEndTime = -1;\r
                boolean lastIsNull = true;\r
                for (ITmfStateInterval irqInterval : irqIntervals) {\r
                    long time = irqInterval.getStartTime();\r
                    long duration = irqInterval.getEndTime() - time + 1;\r
                    if (!irqInterval.getStateValue().isNull()) {\r
                        int cpu = irqInterval.getStateValue().unboxInt();\r
                        eventList.add(new ResourcesEvent(entry, time, duration, cpu));\r
                        lastIsNull = false;\r
                    } else {\r
                        if (lastEndTime != time && lastEndTime != -1 && lastIsNull) {\r
                            eventList.add(new ResourcesEvent(entry, lastEndTime, time - lastEndTime, -1));\r
                        }\r
                        if (includeNull) {\r
                            eventList.add(new ResourcesEvent(entry, time, duration));\r
                        }\r
                        lastIsNull = true;\r
                    }\r
                    lastEndTime = time + duration;\r
                }\r
            } else if (entry.getType().equals(Type.SOFT_IRQ)) {\r
                List<ITmfStateInterval> softIrqIntervals = ssq.queryHistoryRange(quark, startTime, endTime - 1, resolution);\r
                eventList = new ArrayList<ITimeEvent>(softIrqIntervals.size());\r
                long lastEndTime = -1;\r
                boolean lastIsNull = true;\r
                for (ITmfStateInterval softIrqInterval : softIrqIntervals) {\r
                    long time = softIrqInterval.getStartTime();\r
                    long duration = softIrqInterval.getEndTime() - time + 1;\r
                    if (!softIrqInterval.getStateValue().isNull()) {\r
                        int cpu = softIrqInterval.getStateValue().unboxInt();\r
                        eventList.add(new ResourcesEvent(entry, time, duration, cpu));\r
                    } else {\r
                        if (lastEndTime != time && lastEndTime != -1 && lastIsNull) {\r
                            eventList.add(new ResourcesEvent(entry, lastEndTime, time - lastEndTime, -1));\r
                        }\r
                        if (includeNull) {\r
                            eventList.add(new ResourcesEvent(entry, time, duration));\r
                        }\r
                        lastIsNull = true;\r
                    }\r
                    lastEndTime = time + duration;\r
                }\r
            }\r
        } catch (AttributeNotFoundException e) {\r
            e.printStackTrace();\r
        } catch (TimeRangeException e) {\r
            e.printStackTrace();\r
        } catch (StateValueTypeException e) {\r
            e.printStackTrace();\r
        }\r
        return eventList;\r
    }\r
\r
    private void refresh(final long windowRange) {\r
        Display.getDefault().asyncExec(new Runnable() {\r
            @Override\r
            public void run() {\r
                if (fTimeGraphViewer.getControl().isDisposed()) {\r
                    return;\r
                }\r
                ITimeGraphEntry[] entries = fEntryList.toArray(new ITimeGraphEntry[0]);\r
                Arrays.sort(entries);\r
                fTimeGraphViewer.setInput(entries);\r
                fTimeGraphViewer.setTimeBounds(fStartTime, fEndTime);\r
                \r
                long endTime = fStartTime + windowRange;\r
\r
                if (fEndTime < endTime) {\r
                    endTime = fEndTime;\r
                }\r
                fTimeGraphViewer.setStartFinishTime(fStartTime, endTime);\r
                \r
                startZoomThread(fStartTime, endTime);\r
            }\r
        });\r
    }\r
\r
\r
    private void redraw() {\r
        Display.getDefault().asyncExec(new Runnable() {\r
            @Override\r
            public void run() {\r
                if (fTimeGraphViewer.getControl().isDisposed()) {\r
                    return;\r
                }\r
                fTimeGraphViewer.getControl().redraw();\r
                fTimeGraphViewer.getControl().update();\r
            }\r
        });\r
    }\r
\r
    private void startZoomThread(long startTime, long endTime) {\r
        if (fZoomThread != null) {\r
            fZoomThread.cancel();\r
        }\r
        fZoomThread = new ZoomThread(startTime, endTime);\r
        fZoomThread.start();\r
    }\r
    \r
    private void makeActions() {\r
        fPreviousResourceAction = fTimeGraphViewer.getPreviousItemAction();\r
        fPreviousResourceAction.setText(Messages.ResourcesView_previousResourceActionNameText);\r
        fPreviousResourceAction.setToolTipText(Messages.ResourcesView_previousResourceActionToolTipText);\r
        fNextResourceAction = fTimeGraphViewer.getNextItemAction();\r
        fNextResourceAction.setText(Messages.ResourcesView_nextResourceActionNameText);\r
        fNextResourceAction.setToolTipText(Messages.ResourcesView_previousResourceActionToolTipText);\r
    }\r
    \r
    private void contributeToActionBars() {\r
        IActionBars bars = getViewSite().getActionBars();\r
        fillLocalToolBar(bars.getToolBarManager());\r
    }\r
    \r
    private void fillLocalToolBar(IToolBarManager manager) {\r
        manager.add(fTimeGraphViewer.getShowLegendAction());\r
        manager.add(new Separator());\r
        manager.add(fTimeGraphViewer.getResetScaleAction());\r
        manager.add(fTimeGraphViewer.getPreviousEventAction());\r
        manager.add(fTimeGraphViewer.getNextEventAction());\r
        manager.add(fPreviousResourceAction);\r
        manager.add(fNextResourceAction);\r
        manager.add(fTimeGraphViewer.getZoomInAction());\r
        manager.add(fTimeGraphViewer.getZoomOutAction());\r
        manager.add(new Separator());\r
    }\r
}\r