[deliverable/tracecompass.git] / org.eclipse.linuxtools.tmf.ui / src / org / eclipse / linuxtools / tmf / ui / views / timechart / TimeChartView.java

/*******************************************************************************\r
 * Copyright (c) 2010 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.tmf.ui.views.timechart;\r
\r
import java.util.ArrayList;\r
import java.util.HashMap;\r
import java.util.Iterator;\r
import java.util.Map;\r
\r
import org.eclipse.core.resources.IMarker;\r
import org.eclipse.core.resources.IMarkerDelta;\r
import org.eclipse.core.resources.IResource;\r
import org.eclipse.core.resources.IResourceChangeEvent;\r
import org.eclipse.core.resources.IResourceChangeListener;\r
import org.eclipse.core.resources.IResourceDelta;\r
import org.eclipse.core.resources.ResourcesPlugin;\r
import org.eclipse.linuxtools.tmf.event.TmfEvent;\r
import org.eclipse.linuxtools.tmf.event.TmfTimestamp;\r
import org.eclipse.linuxtools.tmf.filter.ITmfFilter;\r
import org.eclipse.linuxtools.tmf.signal.TmfSignalHandler;\r
import org.eclipse.linuxtools.tmf.signal.TmfTimeSynchSignal;\r
import org.eclipse.linuxtools.tmf.signal.TmfTraceSelectedSignal;\r
import org.eclipse.linuxtools.tmf.signal.TmfTraceUpdatedSignal;\r
import org.eclipse.linuxtools.tmf.trace.ITmfTrace;\r
import org.eclipse.linuxtools.tmf.trace.TmfContext;\r
import org.eclipse.linuxtools.tmf.ui.editors.ITmfTraceEditor;\r
import org.eclipse.linuxtools.tmf.ui.signal.TmfTraceClosedSignal;\r
import org.eclipse.linuxtools.tmf.ui.signal.TmfTraceOpenedSignal;\r
import org.eclipse.linuxtools.tmf.ui.viewers.TmfViewerFactory;\r
import org.eclipse.linuxtools.tmf.ui.viewers.events.ITmfEventsFilterListener;\r
import org.eclipse.linuxtools.tmf.ui.viewers.events.ITmfEventsFilterProvider;\r
import org.eclipse.linuxtools.tmf.ui.viewers.timeAnalysis.ITimeAnalysisViewer;\r
import org.eclipse.linuxtools.tmf.ui.viewers.timeAnalysis.ITmfTimeScaleSelectionListener;\r
import org.eclipse.linuxtools.tmf.ui.viewers.timeAnalysis.ITmfTimeSelectionListener;\r
import org.eclipse.linuxtools.tmf.ui.viewers.timeAnalysis.TmfTimeScaleSelectionEvent;\r
import org.eclipse.linuxtools.tmf.ui.viewers.timeAnalysis.TmfTimeSelectionEvent;\r
import org.eclipse.linuxtools.tmf.ui.viewers.timeAnalysis.model.ITimeEvent;\r
import org.eclipse.linuxtools.tmf.ui.viewers.timeAnalysis.model.ITmfTimeAnalysisEntry;\r
import org.eclipse.linuxtools.tmf.ui.views.TmfView;\r
import org.eclipse.linuxtools.tmf.ui.views.colors.ColorSetting;\r
import org.eclipse.linuxtools.tmf.ui.views.colors.ColorSettingsManager;\r
import org.eclipse.linuxtools.tmf.ui.views.colors.IColorSettingsListener;\r
import org.eclipse.linuxtools.tmf.ui.views.timechart.TimeChartEvent.RankRange;\r
import org.eclipse.swt.SWT;\r
import org.eclipse.swt.layout.GridLayout;\r
import org.eclipse.swt.widgets.Composite;\r
import org.eclipse.swt.widgets.Display;\r
import org.eclipse.ui.IEditorPart;\r
import org.eclipse.ui.IEditorReference;\r
\r
public class TimeChartView extends TmfView implements ITmfTimeScaleSelectionListener, ITmfTimeSelectionListener, IColorSettingsListener,\r
        IResourceChangeListener, ITmfEventsFilterListener {\r
\r
    public static final String ID = "org.eclipse.linuxtools.tmf.ui.views.timechart"; //$NON-NLS-1$\r
\r
    private static final byte TIMESTAMP_SCALE = -9;\r
\r
    private final int fDisplayWidth;\r
    private Composite fComposite;\r
    private ITimeAnalysisViewer fViewer;\r
    private final ArrayList<TimeChartAnalysisEntry> fTimeAnalysisEntries = new ArrayList<TimeChartAnalysisEntry>();\r
    private final Map<ITmfTrace, TimeChartDecorationProvider> fDecorationProviders = new HashMap<ITmfTrace, TimeChartDecorationProvider>();\r
    private ArrayList<DecorateThread> fDecorateThreads;\r
    private long fStartTime = 0;\r
    private long fStopTime = Long.MAX_VALUE;\r
    private boolean fRefreshBusy = false;\r
    private boolean fRefreshPending = false;\r
    private final Object fSyncObj = new Object();\r
\r
    public TimeChartView() {\r
        super("Time Chart"); //$NON-NLS-1$\r
        fDisplayWidth = Display.getDefault().getBounds().width;\r
    }\r
\r
    @Override\r
    public void createPartControl(Composite parent) {\r
        fComposite = new Composite(parent, SWT.NONE);\r
        GridLayout gl = new GridLayout();\r
        gl.marginWidth = 0;\r
        gl.marginHeight = 0;\r
        fComposite.setLayout(gl);\r
\r
        fViewer = TmfViewerFactory.createViewer(fComposite, new TimeChartAnalysisProvider());\r
        fViewer.groupTraces(false);\r
        fViewer.setTimeCalendarFormat(true);\r
        fViewer.setAcceptSelectionAPIcalls(true);\r
        fViewer.addWidgetTimeScaleSelectionListner(this);\r
        fViewer.addWidgetSelectionListner(this);\r
        fViewer.setMinimumItemWidth(1);\r
\r
        IEditorReference[] editorReferences = getSite().getPage().getEditorReferences();\r
        for (IEditorReference editorReference : editorReferences) {\r
            IEditorPart editor = editorReference.getEditor(false);\r
            if (editor instanceof ITmfTraceEditor) {\r
                ITmfTrace trace = ((ITmfTraceEditor) editor).getTrace();\r
                if (trace != null) {\r
                    IResource resource = ((ITmfTraceEditor) editor).getResource();\r
                    TimeChartAnalysisEntry timeAnalysisEntry = new TimeChartAnalysisEntry(trace, fDisplayWidth * 2);\r
                    fTimeAnalysisEntries.add(timeAnalysisEntry);\r
                    fDecorationProviders.put(trace, new TimeChartDecorationProvider(resource));\r
                    Thread thread = new ProcessTraceThread(timeAnalysisEntry);\r
                    thread.start();\r
                }\r
            }\r
        }\r
        fViewer.display(fTimeAnalysisEntries.toArray(new TimeChartAnalysisEntry[0]));\r
\r
        fDecorateThreads = new ArrayList<DecorateThread>();\r
        ColorSettingsManager.addColorSettingsListener(this);\r
        ResourcesPlugin.getWorkspace().addResourceChangeListener(this, IResourceChangeEvent.POST_CHANGE);\r
    }\r
\r
    @Override\r
    public void dispose() {\r
        ResourcesPlugin.getWorkspace().removeResourceChangeListener(this);\r
        for (DecorateThread thread : fDecorateThreads) {\r
            thread.cancel();\r
        }\r
        ColorSettingsManager.removeColorSettingsListener(this);\r
        super.dispose();\r
    }\r
\r
    @Override\r
    public void setFocus() {\r
        super.setFocus();\r
        fViewer.setFocus();\r
    }\r
\r
    private class ProcessTraceThread extends Thread {\r
\r
        private final TimeChartAnalysisEntry fTimeAnalysisEntry;\r
\r
        public ProcessTraceThread(TimeChartAnalysisEntry timeAnalysisEntry) {\r
            super("ProcessTraceJob:" + timeAnalysisEntry.getName()); //$NON-NLS-1$\r
            fTimeAnalysisEntry = timeAnalysisEntry;\r
        }\r
\r
        @Override\r
        public void run() {\r
            updateTraceEntry(fTimeAnalysisEntry, Long.MAX_VALUE, 0, Long.MAX_VALUE);\r
        }\r
    }\r
\r
    private void updateTraceEntry(TimeChartAnalysisEntry timeAnalysisEntry, long stopRank, long startTime, long stopTime) {\r
        ITmfTrace trace = timeAnalysisEntry.getTrace();\r
        TimeChartDecorationProvider decorationProvider = fDecorationProviders.get(trace);\r
        if (decorationProvider == null) {\r
            return; // the trace has been closed\r
        }\r
        TmfContext context = null;\r
        // TmfTimestamp lastTimestamp = null;\r
        boolean done = false;\r
        while (!done) {\r
            synchronized (timeAnalysisEntry) {\r
                if (timeAnalysisEntry.getLastRank() >= trace.getNbEvents()) {\r
                    done = true;\r
                    break;\r
                }\r
                if (context == null || context.getRank() != timeAnalysisEntry.getLastRank()) {\r
                    if (context != null) {\r
                        context.dispose();\r
                    }\r
                    if (timeAnalysisEntry.getLastRank() != -1) {\r
                        context = trace.seekEvent(timeAnalysisEntry.getLastRank());\r
                    } else {\r
                        // context = trace.seekLocation(null);\r
                        context = trace.seekEvent(0);\r
                    }\r
                }\r
                while (true) {\r
                    long rank = context.getRank();\r
                    TmfEvent event = trace.getNextEvent(context);\r
                    if (event == null) {\r
                        done = true;\r
                        break;\r
                    }\r
                    // if (!event.getTimestamp().equals(lastTimestamp)) {\r
                    TimeChartEvent timeEvent = new TimeChartEvent(timeAnalysisEntry, event, rank, decorationProvider);\r
                    if (timeEvent.getTime() >= startTime && timeEvent.getTime() <= stopTime) {\r
                        timeAnalysisEntry.addTraceEvent(timeEvent);\r
                    }\r
                    // lastTimestamp = event.getTimestamp();\r
                    // } *** commented out so that color setting priority gets\r
                    // set even if the event has same time\r
                    if (context.getRank() == trace.getNbEvents() || context.getRank() == stopRank) {\r
                        done = true;\r
                        break;\r
                    }\r
                    if (context.getRank() % trace.getCacheSize() == 1) {\r
                        // break for UI refresh\r
                        break;\r
                    }\r
                }\r
                // timeAnalysisEntry.setLastRank(Math.min(trace.getNbEvents(),\r
                // stopRank));\r
                timeAnalysisEntry.setLastRank(context.getRank());\r
            }\r
            refreshViewer(false);\r
        }\r
        if (context != null) {\r
            context.dispose();\r
        }\r
    }\r
\r
    private void refreshViewer(boolean resetTimeIntervals) {\r
        if (fComposite == null) {\r
            return;\r
        }\r
        synchronized (fSyncObj) {\r
            if (fRefreshBusy) {\r
                fRefreshPending = true;\r
                return;\r
            } else {\r
                fRefreshBusy = true;\r
            }\r
        }\r
        final boolean reset = resetTimeIntervals;\r
        // Perform the refresh on the UI thread\r
        Display.getDefault().asyncExec(new Runnable() {\r
            @Override\r
            public void run() {\r
                if (fComposite.isDisposed())\r
                    return;\r
                fViewer.display(fTimeAnalysisEntries.toArray(new TimeChartAnalysisEntry[0]));\r
                if (reset) {\r
                    fViewer.resetStartFinishTime();\r
                }\r
                synchronized (fSyncObj) {\r
                    fRefreshBusy = false;\r
                    if (fRefreshPending) {\r
                        fRefreshPending = false;\r
                        refreshViewer(reset);\r
                    }\r
                }\r
            }\r
        });\r
    }\r
\r
    private void itemize(long startTime, long stopTime) {\r
        for (int i = 0; i < fTimeAnalysisEntries.size(); i++) {\r
            Thread thread = new ItemizeThread(fTimeAnalysisEntries.get(i), startTime, stopTime);\r
            thread.start();\r
        }\r
    }\r
\r
    private class ItemizeThread extends Thread {\r
\r
        private final TimeChartAnalysisEntry fTimeAnalysisEntry;\r
        private final long fStartTime;\r
        private final long fStopTime;\r
        private final long fMaxDuration;\r
\r
        private ItemizeThread(TimeChartAnalysisEntry timeAnalysisEntry, long startTime, long stopTime) {\r
            super("Itemize Thread:" + timeAnalysisEntry.getName()); //$NON-NLS-1$\r
            fTimeAnalysisEntry = timeAnalysisEntry;\r
            fStartTime = startTime;\r
            fStopTime = stopTime;\r
            fMaxDuration = 3 * (fStopTime - fStartTime) / fDisplayWidth;\r
        }\r
\r
        @Override\r
        public void run() {\r
            itemizeTraceEntry(fTimeAnalysisEntry);\r
        }\r
\r
        public void itemizeTraceEntry(TimeChartAnalysisEntry timeAnalysisEntry) {\r
            Iterator<ITimeEvent> iterator = timeAnalysisEntry.getTraceEventsIterator();\r
            TimeChartEvent event = null;\r
            boolean hasNext = true;\r
            while (hasNext) {\r
                synchronized (timeAnalysisEntry) {\r
                    while (hasNext = iterator.hasNext()) {\r
                        event = (TimeChartEvent) iterator.next();\r
                        if (event.getTime() + event.getDuration() > fStartTime && event.getTime() < fStopTime && event.getDuration() > fMaxDuration\r
                                && event.getNbEvents() > 1) {\r
                            break;\r
                        }\r
                    }\r
                }\r
                if (hasNext) {\r
                    if (event.getItemizedEntry() == null) {\r
                        itemizeEvent(event);\r
                    } else {\r
                        itemizeTraceEntry(event.getItemizedEntry());\r
                    }\r
                }\r
            }\r
        }\r
\r
        public void itemizeEvent(TimeChartEvent event) {\r
            synchronized (event) {\r
                if (event.isItemizing()) {\r
                    return;\r
                }\r
                event.setItemizing(true);\r
            }\r
            TimeChartAnalysisEntry timeAnalysisEntry = new TimeChartAnalysisEntry(fTimeAnalysisEntry.getTrace(), (int) Math.min(\r
                    event.getNbEvents() + 1, fDisplayWidth * 2));\r
            synchronized (event.getRankRangeList()) {\r
                for (RankRange range : event.getRankRangeList()) {\r
                    timeAnalysisEntry.setLastRank(range.getFirstRank());\r
                    updateTraceEntry(timeAnalysisEntry, range.getLastRank() + 1, event.getTime(), event.getTime() + event.getDuration());\r
                }\r
            }\r
            event.setItemizedEntry(timeAnalysisEntry);\r
            refreshViewer(false);\r
            itemizeTraceEntry(timeAnalysisEntry);\r
            synchronized (event) {\r
                event.setItemizing(false);\r
            }\r
        }\r
    }\r
\r
    private void redecorate() {\r
        synchronized (fDecorateThreads) {\r
            for (DecorateThread thread : fDecorateThreads) {\r
                thread.cancel();\r
            }\r
            fDecorateThreads.clear();\r
            for (int i = 0; i < fTimeAnalysisEntries.size(); i++) {\r
                DecorateThread thread = new DecorateThread(fTimeAnalysisEntries.get(i));\r
                thread.start();\r
                fDecorateThreads.add(thread);\r
            }\r
        }\r
    }\r
\r
    private class DecorateThread extends Thread {\r
        private volatile boolean interrupted = false;\r
        private final TimeChartAnalysisEntry fTimeAnalysisEntry;\r
        private final TimeChartDecorationProvider fDecorationProvider;\r
        private TmfContext fContext;\r
        private int fCount = 0;\r
\r
        private DecorateThread(TimeChartAnalysisEntry timeAnalysisEntry) {\r
            super("Decorate Thread:" + timeAnalysisEntry.getName()); //$NON-NLS-1$\r
            fTimeAnalysisEntry = timeAnalysisEntry;\r
            fDecorationProvider = fDecorationProviders.get(timeAnalysisEntry.getTrace());\r
        }\r
\r
        @Override\r
        public void run() {\r
            resetTraceEntry(fTimeAnalysisEntry);\r
            refreshViewer(false);\r
            decorateTraceEntry(fTimeAnalysisEntry, null);\r
            refreshViewer(false);\r
            synchronized (fDecorateThreads) {\r
                fDecorateThreads.remove(this);\r
            }\r
        }\r
\r
        public void resetTraceEntry(TimeChartAnalysisEntry timeAnalysisEntry) {\r
            Iterator<ITimeEvent> iterator = timeAnalysisEntry.getTraceEventsIterator();\r
            TimeChartEvent event = null;\r
            boolean hasNext = true;\r
            while (!interrupted && hasNext) {\r
                synchronized (timeAnalysisEntry) {\r
                    while (hasNext = iterator.hasNext()) {\r
                        event = (TimeChartEvent) iterator.next();\r
                        break;\r
                    }\r
                }\r
                if (hasNext) {\r
                    // TODO possible concurrency problem here with ItemizeJob\r
                    event.setColorSettingPriority(ColorSettingsManager.PRIORITY_NONE);\r
                    if (event.getItemizedEntry() != null) {\r
                        resetTraceEntry(event.getItemizedEntry());\r
                    }\r
                }\r
            }\r
        }\r
\r
        public void decorateTraceEntry(TimeChartAnalysisEntry timeAnalysisEntry, TimeChartEvent parentEvent) {\r
            // Set max duration high to ensure iterator does not consider\r
            // itemized events\r
            Iterator<ITimeEvent> iterator = timeAnalysisEntry.getTraceEventsIterator(0, Long.MAX_VALUE, Long.MAX_VALUE);\r
            TimeChartEvent event = null;\r
            int entryPriority = ColorSettingsManager.PRIORITY_NONE;\r
            boolean entryIsBookmarked = false;\r
            boolean entryIsVisible = false;\r
            boolean entryIsSearchMatch = false;\r
            boolean hasNext = true;\r
            while (!interrupted && hasNext) {\r
                synchronized (timeAnalysisEntry) {\r
                    while (hasNext = iterator.hasNext()) {\r
                        event = (TimeChartEvent) iterator.next();\r
                        break;\r
                    }\r
                }\r
                if (hasNext) {\r
                    // TODO possible concurrency problem here with ItemizeJob\r
                    if (event.getItemizedEntry() == null) {\r
                        decorateEvent(event);\r
                    } else {\r
                        decorateTraceEntry(event.getItemizedEntry(), event);\r
                    }\r
                    entryPriority = Math.min(entryPriority, event.getColorSettingPriority());\r
                    entryIsBookmarked |= event.isBookmarked();\r
                    entryIsVisible |= event.isVisible();\r
                    entryIsSearchMatch |= event.isSearchMatch();\r
                    if (++fCount % timeAnalysisEntry.getTrace().getCacheSize() == 0) {\r
                        refreshViewer(false);\r
                    }\r
                }\r
            }\r
            if (parentEvent != null) {\r
                parentEvent.setColorSettingPriority(entryPriority);\r
                parentEvent.setIsBookmarked(entryIsBookmarked);\r
                parentEvent.setIsVisible(entryIsVisible);\r
                parentEvent.setIsSearchMatch(entryIsSearchMatch);\r
            }\r
        }\r
\r
        public void decorateEvent(TimeChartEvent timeChartEvent) {\r
            // TODO possible concurrency problem here with ItemizeJob\r
            TimeChartAnalysisEntry timeAnalysisEntry = (TimeChartAnalysisEntry) timeChartEvent.getEntry();\r
            ITmfTrace trace = timeAnalysisEntry.getTrace();\r
            int priority = ColorSettingsManager.PRIORITY_NONE;\r
            boolean isBookmarked = false;\r
            boolean isVisible = false;\r
            boolean isSearchMatch = false;\r
            synchronized (timeChartEvent.getRankRangeList()) {\r
                for (RankRange range : timeChartEvent.getRankRangeList()) {\r
                    if (interrupted)\r
                        return;\r
                    if (fContext == null || fContext.getRank() != range.getFirstRank()) {\r
                        fContext = trace.seekEvent(range.getFirstRank());\r
                        fContext.setRank(range.getFirstRank());\r
                    }\r
                    while (true) {\r
                        if (interrupted)\r
                            return;\r
                        long rank = fContext.getRank();\r
                        TmfEvent event = trace.getNextEvent(fContext);\r
                        if (event == null) {\r
                            break;\r
                        }\r
                        long eventTime = event.getTimestamp().synchronize(0, (byte) -9).getValue();\r
                        if (eventTime >= timeChartEvent.getTime() && eventTime <= timeChartEvent.getTime() + timeChartEvent.getDuration()) {\r
                            priority = Math.min(priority, ColorSettingsManager.getColorSettingPriority(event));\r
                        }\r
                        isBookmarked |= fDecorationProvider.isBookmark(rank);\r
                        isVisible |= fDecorationProvider.isVisible(event);\r
                        isSearchMatch |= fDecorationProvider.isSearchMatch(event);\r
                        if (fContext.getRank() > range.getLastRank()) {\r
                            break;\r
                        }\r
                    }\r
                }\r
            }\r
            timeChartEvent.setColorSettingPriority(priority);\r
            timeChartEvent.setIsBookmarked(isBookmarked);\r
            timeChartEvent.setIsVisible(isVisible);\r
            timeChartEvent.setIsSearchMatch(isSearchMatch);\r
        }\r
\r
        public void cancel() {\r
            interrupted = true;\r
        }\r
    }\r
\r
    // ------------------------------------------------------------------------\r
    // Listeners\r
    // ------------------------------------------------------------------------\r
\r
    @Override\r
    public void tsfTmProcessTimeScaleEvent(TmfTimeScaleSelectionEvent event) {\r
        fStartTime = event.getTime0();\r
        fStopTime = event.getTime1();\r
        itemize(fStartTime, fStopTime);\r
    }\r
\r
    @Override\r
    public void tsfTmProcessSelEvent(TmfTimeSelectionEvent event) {\r
        ITmfTimeAnalysisEntry timeAnalysisEntry = null;\r
        if (event.getSelection() instanceof TimeChartAnalysisEntry) {\r
            timeAnalysisEntry = (TimeChartAnalysisEntry) event.getSelection();\r
        } else if (event.getSelection() instanceof TimeChartEvent) {\r
            timeAnalysisEntry = ((TimeChartEvent) event.getSelection()).getEntry();\r
        }\r
        if (timeAnalysisEntry instanceof TimeChartAnalysisEntry) {\r
            broadcast(new TmfTraceSelectedSignal(this, ((TimeChartAnalysisEntry) timeAnalysisEntry).getTrace()));\r
        }\r
        broadcast(new TmfTimeSynchSignal(this, new TmfTimestamp(event.getSelectedTime(), TIMESTAMP_SCALE)));\r
    }\r
\r
    @Override\r
    public void colorSettingsChanged(ColorSetting[] colorSettings) {\r
        redecorate();\r
    }\r
\r
    @Override\r
    public void resourceChanged(IResourceChangeEvent event) {\r
        for (IMarkerDelta delta : event.findMarkerDeltas(IMarker.BOOKMARK, false)) {\r
            for (TimeChartDecorationProvider provider : fDecorationProviders.values()) {\r
                if (delta.getResource().equals(provider.getResource())) {\r
                    if (delta.getKind() == IResourceDelta.CHANGED && delta.getMarker().getAttribute(IMarker.LOCATION, -1) != -1) {\r
                        provider.refreshBookmarks();\r
                    } else if (delta.getKind() == IResourceDelta.REMOVED) {\r
                        provider.refreshBookmarks();\r
                    }\r
                }\r
            }\r
        }\r
        redecorate();\r
    }\r
\r
    @Override\r
    public void filterApplied(ITmfFilter filter, ITmfTrace trace) {\r
        TimeChartDecorationProvider decorationProvider = fDecorationProviders.get(trace);\r
        decorationProvider.filterApplied(filter);\r
        redecorate();\r
    }\r
\r
    @Override\r
    public void searchApplied(ITmfFilter filter, ITmfTrace trace) {\r
        TimeChartDecorationProvider decorationProvider = fDecorationProviders.get(trace);\r
        decorationProvider.searchApplied(filter);\r
        redecorate();\r
    }\r
\r
    // ------------------------------------------------------------------------\r
    // Signal handlers\r
    // ------------------------------------------------------------------------\r
\r
    @TmfSignalHandler\r
    public void traceOpened(TmfTraceOpenedSignal signal) {\r
        if (fTimeAnalysisEntries == null)\r
            return;\r
        final ITmfTrace trace = signal.getTrace();\r
        final IResource resource = signal.getResource();\r
        final ITmfEventsFilterProvider eventsFilterProvider = signal.getEventsFilterProvider();\r
        TimeChartAnalysisEntry timeAnalysisEntry = null;\r
        for (int i = 0; i < fTimeAnalysisEntries.size(); i++) {\r
            if (fTimeAnalysisEntries.get(i).getTrace().equals(trace)) {\r
                timeAnalysisEntry = fTimeAnalysisEntries.get(i);\r
                break;\r
            }\r
        }\r
        if (timeAnalysisEntry == null) {\r
            timeAnalysisEntry = new TimeChartAnalysisEntry(trace, fDisplayWidth * 2);\r
            fTimeAnalysisEntries.add(timeAnalysisEntry);\r
            fDecorationProviders.put(trace, new TimeChartDecorationProvider(resource));\r
            Thread thread = new ProcessTraceThread(timeAnalysisEntry);\r
            thread.start();\r
        }\r
        refreshViewer(true);\r
        if (eventsFilterProvider != null) {\r
            eventsFilterProvider.addEventsFilterListener(this);\r
        }\r
    }\r
\r
    @TmfSignalHandler\r
    public void traceClosed(TmfTraceClosedSignal signal) {\r
        if (fTimeAnalysisEntries == null)\r
            return;\r
        final ITmfTrace trace = signal.getTrace();\r
        for (int i = 0; i < fTimeAnalysisEntries.size(); i++) {\r
            if (fTimeAnalysisEntries.get(i).getTrace().equals(trace)) {\r
                fTimeAnalysisEntries.remove(i);\r
                fDecorationProviders.remove(trace);\r
                refreshViewer(true);\r
                break;\r
            }\r
        }\r
    }\r
\r
    @TmfSignalHandler\r
    public void traceSelected(TmfTraceSelectedSignal signal) {\r
        if (signal.getSource() != this && fTimeAnalysisEntries != null) {\r
            ITmfTrace trace = signal.getTrace();\r
            for (int i = 0; i < fTimeAnalysisEntries.size(); i++) {\r
                if (fTimeAnalysisEntries.get(i).getTrace().equals(trace)) {\r
                    fViewer.setSelectedTrace(fTimeAnalysisEntries.get(i));\r
                    break;\r
                }\r
            }\r
        }\r
    }\r
\r
    @TmfSignalHandler\r
    public void traceUpdated(TmfTraceUpdatedSignal signal) {\r
        if (fTimeAnalysisEntries == null)\r
            return;\r
        final ITmfTrace trace = signal.getTrace();\r
        for (int i = 0; i < fTimeAnalysisEntries.size(); i++) {\r
            TimeChartAnalysisEntry timeAnalysisEntry = fTimeAnalysisEntries.get(i);\r
            if (timeAnalysisEntry.getTrace().equals(trace)) {\r
                updateTraceEntry(timeAnalysisEntry, Long.MAX_VALUE, 0, Long.MAX_VALUE);\r
                break;\r
            }\r
        }\r
    }\r
\r
    @TmfSignalHandler\r
    public void currentTimeUpdated(TmfTimeSynchSignal signal) {\r
        long time = signal.getCurrentTime().synchronize(0, TIMESTAMP_SCALE).getValue();\r
        fViewer.setSelectedTime(time, true, this);\r
    }\r
\r
}\r