[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.IFile;\r
import org.eclipse.core.resources.IMarker;\r
import org.eclipse.core.resources.IMarkerDelta;\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.core.event.ITmfEvent;\r
import org.eclipse.linuxtools.tmf.core.event.TmfTimestamp;\r
import org.eclipse.linuxtools.tmf.core.filter.ITmfFilter;\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.signal.TmfTraceSelectedSignal;\r
import org.eclipse.linuxtools.tmf.core.signal.TmfTraceUpdatedSignal;\r
import org.eclipse.linuxtools.tmf.core.trace.ITmfContext;\r
import org.eclipse.linuxtools.tmf.core.trace.ITmfTrace;\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.events.ITmfEventsFilterListener;\r
import org.eclipse.linuxtools.tmf.ui.viewers.events.ITmfEventsFilterProvider;\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.linuxtools.tmf.ui.widgets.timegraph.ITimeGraphPresentationProvider;\r
import org.eclipse.linuxtools.tmf.ui.widgets.timegraph.ITimeGraphRangeListener;\r
import org.eclipse.linuxtools.tmf.ui.widgets.timegraph.ITimeGraphSelectionListener;\r
import org.eclipse.linuxtools.tmf.ui.widgets.timegraph.ITimeGraphTimeListener;\r
import org.eclipse.linuxtools.tmf.ui.widgets.timegraph.TimeGraphRangeUpdateEvent;\r
import org.eclipse.linuxtools.tmf.ui.widgets.timegraph.TimeGraphSelectionEvent;\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.swt.SWT;\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
/**\r
 * Generic Time Chart view, which is similar to a Gantt chart for trace analysis\r
 *\r
 * @version 1.0\r
 * @author Patrick Tasse\r
 */\r
public class TimeChartView extends TmfView implements ITimeGraphRangeListener,\r
        ITimeGraphSelectionListener, ITimeGraphTimeListener,\r
        IColorSettingsListener, IResourceChangeListener,\r
        ITmfEventsFilterListener {\r
\r
    /** TimeChartView's ID */\r
    public static final String ID = "org.eclipse.linuxtools.tmf.ui.views.timechart"; //$NON-NLS-1$\r
\r
    private static final int TIMESTAMP_SCALE = -9;\r
\r
    private final int fDisplayWidth;\r
    private TimeGraphViewer 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 boolean fRedrawBusy = false;\r
    private boolean fRedrawPending = false;\r
    private final Object fSyncObj = new Object();\r
    private ITimeGraphPresentationProvider fPresentationProvider;\r
\r
    /**\r
     * Default constructor\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
        fViewer = new TimeGraphViewer(parent, SWT.NONE);\r
        fPresentationProvider = new TimeChartAnalysisProvider();\r
        fViewer.setTimeGraphProvider(fPresentationProvider);\r
        fViewer.setTimeCalendarFormat(true);\r
        fViewer.addTimeListener(this);\r
        fViewer.addRangeListener(this);\r
        fViewer.addSelectionListener(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
                    IFile bookmarksFile = ((ITmfTraceEditor) editor).getBookmarksFile();\r
                    TimeChartAnalysisEntry timeAnalysisEntry = new TimeChartAnalysisEntry(trace, fDisplayWidth * 2);\r
                    fTimeAnalysisEntries.add(timeAnalysisEntry);\r
                    fDecorationProviders.put(trace, new TimeChartDecorationProvider(bookmarksFile));\r
                    Thread thread = new ProcessTraceThread(timeAnalysisEntry);\r
                    thread.start();\r
                }\r
            }\r
        }\r
        fViewer.setInput(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
        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
        ITmfContext 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
                    ITmfEvent event = trace.getNext(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
            redrawViewer(true);\r
        }\r
        if (context != null) {\r
            context.dispose();\r
        }\r
    }\r
\r
    private void refreshViewer() {\r
        synchronized (fSyncObj) {\r
            if (fRefreshBusy) {\r
                fRefreshPending = true;\r
                return;\r
            }\r
            fRefreshBusy = true;\r
        }\r
        // Perform the refresh on the UI thread\r
        Display.getDefault().asyncExec(new Runnable() {\r
            @Override\r
            public void run() {\r
                if (fViewer.getControl().isDisposed()) {\r
                    return;\r
                }\r
                fViewer.setInput(fTimeAnalysisEntries.toArray(new TimeChartAnalysisEntry[0]));\r
                fViewer.resetStartFinishTime();\r
                synchronized (fSyncObj) {\r
                    fRefreshBusy = false;\r
                    if (fRefreshPending) {\r
                        fRefreshPending = false;\r
                        refreshViewer();\r
                    }\r
                }\r
            }\r
        });\r
    }\r
\r
    private void redrawViewer(boolean resetTimeIntervals) {\r
        synchronized (fSyncObj) {\r
            if (fRedrawBusy) {\r
                fRedrawPending = true;\r
                return;\r
            }\r
            fRedrawBusy = true;\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 (fViewer.getControl().isDisposed()) {\r
                    return;\r
                }\r
                if (reset) {\r
                    fViewer.setTimeRange(fTimeAnalysisEntries.toArray(new TimeChartAnalysisEntry[0]));\r
                    fViewer.setTimeBounds();\r
                }\r
                fViewer.getControl().redraw();\r
                fViewer.getControl().update();\r
                synchronized (fSyncObj) {\r
                    fRedrawBusy = false;\r
                    if (fRedrawPending) {\r
                        fRedrawPending = false;\r
                        redrawViewer(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.getTimeEventsIterator();\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
            redrawViewer(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 ITmfContext 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
            redrawViewer(false);\r
            decorateTraceEntry(fTimeAnalysisEntry, null);\r
            redrawViewer(false);\r
            synchronized (fDecorateThreads) {\r
                fDecorateThreads.remove(this);\r
            }\r
            if (fContext != null) {\r
            	fContext.dispose();\r
            }\r
        }\r
\r
        public void resetTraceEntry(TimeChartAnalysisEntry timeAnalysisEntry) {\r
            Iterator<ITimeEvent> iterator = timeAnalysisEntry.getTimeEventsIterator();\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.getTimeEventsIterator(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
                        redrawViewer(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
                    }\r
                    if (fContext == null || fContext.getRank() != range.getFirstRank()) {\r
                        if (fContext != null) {\r
                        	fContext.dispose();\r
                        }\r
                        fContext = trace.seekEvent(range.getFirstRank());\r
                        fContext.setRank(range.getFirstRank());\r
                    }\r
                    while (true) {\r
                        if (interrupted) {\r
                            return;\r
                        }\r
                        long rank = fContext.getRank();\r
                        ITmfEvent event = trace.getNext(fContext);\r
                        if (event == null) {\r
                            break;\r
                        }\r
                        long eventTime = event.getTimestamp().normalize(0, -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 timeRangeUpdated(TimeGraphRangeUpdateEvent event) {\r
        fStartTime = event.getStartTime();\r
        fStopTime = event.getEndTime();\r
        itemize(fStartTime, fStopTime);\r
    }\r
\r
    @Override\r
    public void selectionChanged(TimeGraphSelectionEvent event) {\r
        ITimeGraphEntry timeAnalysisEntry = null;\r
        if (event.getSelection() instanceof TimeChartAnalysisEntry) {\r
            timeAnalysisEntry = 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
    }\r
\r
    @Override\r
    public void timeSelected(TimeGraphTimeEvent event) {\r
        broadcast(new TmfTimeSynchSignal(this, new TmfTimestamp(event.getTime(), TIMESTAMP_SCALE)));\r
    }\r
\r
    @Override\r
    public void colorSettingsChanged(ColorSetting[] colorSettings) {\r
        // Set presentation provider again to trigger re-creation of new color settings which are stored\r
        // in the TimeGraphControl class\r
        fViewer.setTimeGraphProvider(fPresentationProvider);\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.getBookmarksFile())) {\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
    /**\r
     * Handler for the Trace Opened signal\r
     *\r
     * @param signal\r
     *            The incoming signal\r
     */\r
    @TmfSignalHandler\r
    public void traceOpened(TmfTraceOpenedSignal signal) {\r
        if (fTimeAnalysisEntries == null) {\r
            return;\r
        }\r
        final ITmfTrace trace = signal.getTrace();\r
        final IFile bookmarksFile = signal.getBookmarksFile();\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(bookmarksFile));\r
            Thread thread = new ProcessTraceThread(timeAnalysisEntry);\r
            thread.start();\r
        }\r
        refreshViewer();\r
        if (eventsFilterProvider != null) {\r
            eventsFilterProvider.addEventsFilterListener(this);\r
        }\r
    }\r
\r
    /**\r
     * Handler for the Trace Closed signal\r
     *\r
     * @param signal\r
     *            The incoming signal\r
     */\r
    @TmfSignalHandler\r
    public void traceClosed(TmfTraceClosedSignal signal) {\r
        if (fTimeAnalysisEntries == null) {\r
            return;\r
        }\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();\r
                break;\r
            }\r
        }\r
    }\r
\r
    /**\r
     * Handler for the Trace Selected signal\r
     *\r
     * @param signal\r
     *            The incoming signal\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.setSelection(fTimeAnalysisEntries.get(i));\r
                    break;\r
                }\r
            }\r
        }\r
    }\r
\r
    /**\r
     * Handler for the Trace Updated signal\r
     *\r
     * @param signal\r
     *            The incoming signal\r
     */\r
    @TmfSignalHandler\r
    public void traceUpdated(TmfTraceUpdatedSignal signal) {\r
        if (fTimeAnalysisEntries == null) {\r
            return;\r
        }\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
    /**\r
     * Handler for the Time Synch signal\r
     *\r
     * @param signal\r
     *            The incoming signal\r
     */\r
    @TmfSignalHandler\r
    public void currentTimeUpdated(TmfTimeSynchSignal signal) {\r
        final long time = signal.getCurrentTime().normalize(0, TIMESTAMP_SCALE).getValue();\r
        Display.getDefault().asyncExec(new Runnable() {\r
            @Override\r
            public void run() {\r
                fViewer.setSelectedTime(time, true);\r
            }\r
        });\r
    }\r
\r
}\r