BaseDataProviderTimeGraphMultiViewer.java

/**********************************************************************
 * Copyright (c) 2020 Draeger, Auriga
 *
 * All rights reserved. This program and the accompanying materials are
 * made available under the terms of the Eclipse Public License 2.0 which
 * accompanies this distribution, and is available at
 * https://www.eclipse.org/legal/epl-2.0/
 *
 * SPDX-License-Identifier: EPL-2.0
 **********************************************************************/

package org.eclipse.tracecompass.incubator.internal.tmf.ui.multiview.ui.view.timegraph;

import java.util.ArrayList;
import java.util.Collection;
import java.util.Collections;
import java.util.HashMap;
import java.util.List;
import java.util.Map;
import java.util.Map.Entry;
import java.util.Objects;
import java.util.function.BiFunction;
import java.util.regex.Matcher;
import java.util.regex.Pattern;

import org.eclipse.core.runtime.IProgressMonitor;
import org.eclipse.core.runtime.NullProgressMonitor;
import org.eclipse.core.runtime.SubMonitor;
import org.eclipse.jdt.annotation.NonNull;
import org.eclipse.jdt.annotation.Nullable;
import org.eclipse.jface.action.GroupMarker;
import org.eclipse.jface.action.IContributionItem;
import org.eclipse.jface.action.IMenuManager;
import org.eclipse.jface.action.MenuManager;
import org.eclipse.jface.viewers.ISelection;
import org.eclipse.jface.viewers.IStructuredSelection;
import org.eclipse.swt.widgets.Composite;
import org.eclipse.swt.widgets.Control;
import org.eclipse.swt.widgets.Menu;
import org.eclipse.tracecompass.internal.provisional.tmf.ui.widgets.timegraph.BaseDataProviderTimeGraphPresentationProvider;
import org.eclipse.tracecompass.internal.tmf.ui.Activator;
import org.eclipse.tracecompass.statesystem.core.StateSystemUtils;
import org.eclipse.tracecompass.tmf.core.TmfStrings;
import org.eclipse.tracecompass.tmf.core.dataprovider.DataProviderManager;
import org.eclipse.tracecompass.tmf.core.dataprovider.DataProviderParameterUtils;
import org.eclipse.tracecompass.tmf.core.event.lookup.TmfCallsite;
import org.eclipse.tracecompass.tmf.core.model.CoreFilterProperty;
import org.eclipse.tracecompass.tmf.core.model.IOutputElement;
import org.eclipse.tracecompass.tmf.core.model.annotations.Annotation;
import org.eclipse.tracecompass.tmf.core.model.annotations.AnnotationCategoriesModel;
import org.eclipse.tracecompass.tmf.core.model.annotations.AnnotationModel;
import org.eclipse.tracecompass.tmf.core.model.annotations.IAnnotation.AnnotationType;
import org.eclipse.tracecompass.tmf.core.model.annotations.IOutputAnnotationProvider;
import org.eclipse.tracecompass.tmf.core.model.timegraph.ITimeGraphArrow;
import org.eclipse.tracecompass.tmf.core.model.timegraph.ITimeGraphDataProvider;
import org.eclipse.tracecompass.tmf.core.model.timegraph.ITimeGraphRowModel;
import org.eclipse.tracecompass.tmf.core.model.timegraph.ITimeGraphState;
import org.eclipse.tracecompass.tmf.core.model.timegraph.TimeGraphEntryModel;
import org.eclipse.tracecompass.tmf.core.model.timegraph.TimeGraphModel;
import org.eclipse.tracecompass.tmf.core.model.timegraph.TimeGraphState;
import org.eclipse.tracecompass.tmf.core.model.tree.TmfTreeModel;
import org.eclipse.tracecompass.tmf.core.response.ITmfResponse;
import org.eclipse.tracecompass.tmf.core.response.TmfModelResponse;
import org.eclipse.tracecompass.tmf.core.trace.ITmfTrace;
import org.eclipse.tracecompass.tmf.ui.actions.OpenSourceCodeAction;
import org.eclipse.tracecompass.tmf.ui.views.timegraph.BaseDataProviderTimeGraphView;
import org.eclipse.tracecompass.tmf.ui.widgets.timegraph.ITimeGraphPresentationProvider;
import org.eclipse.tracecompass.tmf.ui.widgets.timegraph.model.ILinkEvent;
import org.eclipse.tracecompass.tmf.ui.widgets.timegraph.model.IMarkerEvent;
import org.eclipse.tracecompass.tmf.ui.widgets.timegraph.model.ITimeEvent;
import org.eclipse.tracecompass.tmf.ui.widgets.timegraph.model.ITimeGraphEntry;
import org.eclipse.tracecompass.tmf.ui.widgets.timegraph.model.MarkerEvent;
import org.eclipse.tracecompass.tmf.ui.widgets.timegraph.model.NamedTimeEvent;
import org.eclipse.tracecompass.tmf.ui.widgets.timegraph.model.NullTimeEvent;
import org.eclipse.tracecompass.tmf.ui.widgets.timegraph.model.TimeEvent;
import org.eclipse.tracecompass.tmf.ui.widgets.timegraph.model.TimeGraphEntry;
import org.eclipse.tracecompass.tmf.ui.widgets.timegraph.model.TimeGraphEntry.Sampling;
import org.eclipse.tracecompass.tmf.ui.widgets.timegraph.model.TimeLinkEvent;
import org.eclipse.tracecompass.tmf.ui.widgets.timegraph.widgets.TimeGraphControl;
import org.eclipse.tracecompass.tmf.ui.widgets.timegraph.widgets.Utils;
import org.eclipse.ui.IWorkbenchActionConstants;
import org.eclipse.ui.IWorkbenchPartSite;

import com.google.common.collect.HashBasedTable;
import com.google.common.collect.HashMultimap;
import com.google.common.collect.ImmutableList;
import com.google.common.collect.Iterables;
import com.google.common.collect.Multimap;
import com.google.common.collect.Table;

/**
 * {@link AbstractTimeGraphMultiViewer} for viewers with data providers.
 * <p>
 * The viewer corresponds (copy-pasted actually) to
 * {@link BaseDataProviderTimeGraphView}.
 *
 * @author Ivan Grinenko
 *
 */
@SuppressWarnings("restriction")
public class BaseDataProviderTimeGraphMultiViewer extends AbstractTimeGraphMultiViewer {

    /**
     * Timeout between updates in the build thread in ms
     */
    protected static final long BUILD_UPDATE_TIMEOUT = 500;

    private static final Pattern SOURCE_REGEX = Pattern.compile("(.*):(\\d+)"); //$NON-NLS-1$

    /**
     * Table of (data provider, model id) to time graph entry. The table should
     * be filled by {@link #buildEntryList} and is read by {@link #zoomEntries}
     * and {@link #getLinkList}.
     */
    protected final Table<ITimeGraphDataProvider<? extends @NonNull TimeGraphEntryModel>, Long, TimeGraphEntry> fEntries = HashBasedTable.create();

    /**
     * Table of (time graph entry, data provider) to model id. The table should
     * be filled by {@link #buildEntryList}.
     *
     * @since 5.2
     */
    protected final Table<@NonNull TimeGraphEntry, ITimeGraphDataProvider<? extends @NonNull TimeGraphEntryModel>, Long> fEntryIds = HashBasedTable.create();

    /**
     * Table of (scope, model id) to time graph entry. The table should be
     * filled by {@link #buildEntryList}.
     *
     * @since 5.2
     */
    protected final Table<Object, Long, TimeGraphEntry> fScopedEntries = HashBasedTable.create();

    /** Map of parent trace to providers */
    private Multimap<ITmfTrace, ITimeGraphDataProvider<? extends @NonNull TimeGraphEntryModel>> fProviders = HashMultimap.create();

    /** Map of parent trace to scopes, for cleanup */
    private Multimap<ITmfTrace, Object> fScopes = HashMultimap.create();

    private final String fProviderId;

    /**
     * Constructor.
     *
     * @param parent
     *            parent composite
     * @param pres
     *            presentation provider
     * @param site
     *            workbench site
     * @param providerId
     *            provider's ID
     */
    public BaseDataProviderTimeGraphMultiViewer(Composite parent, ITimeGraphPresentationProvider pres, IWorkbenchPartSite site, String providerId) {
        super(parent, pres, site);
        fProviderId = providerId;
        createTimeEventContextMenu();
    }

    @Override
    public Control getControl() {
        return getTimeGraphViewer().getTimeAlignedComposite();
    }

    /**
     * Get a data provider ID
     *
     * @return the data provider ID
     */
    protected String getProviderId() {
        return fProviderId;
    }

    @Override
    protected void buildEntryList(@NonNull ITmfTrace trace, @NonNull ITmfTrace parentTrace, @NonNull IProgressMonitor monitor) {
        ITimeGraphDataProvider<@NonNull TimeGraphEntryModel> dataProvider = DataProviderManager
                .getInstance().getOrCreateDataProvider(trace, getProviderId(), ITimeGraphDataProvider.class);
        if (dataProvider == null) {
            return;
        }
        ITimeGraphPresentationProvider presentationProvider = getPresentationProvider();
        if (presentationProvider instanceof BaseDataProviderTimeGraphPresentationProvider) {
            ((BaseDataProviderTimeGraphPresentationProvider) presentationProvider).addProvider(dataProvider, getTooltipResolver(dataProvider));
        }
        boolean complete = false;
        while (!complete && !monitor.isCanceled()) {
            Map<@NonNull String, @NonNull Object> parameters = getFetchTreeParameters();
            TmfModelResponse<TmfTreeModel<@NonNull TimeGraphEntryModel>> response = dataProvider.fetchTree(parameters, monitor);
            if (response.getStatus() == ITmfResponse.Status.FAILED) {
                Activator.getDefault().logError(getClass().getSimpleName() + " Data Provider failed: " + response.getStatusMessage()); //$NON-NLS-1$
                return;
            } else if (response.getStatus() == ITmfResponse.Status.CANCELLED) {
                return;
            }
            complete = response.getStatus() == ITmfResponse.Status.COMPLETED;

            TmfTreeModel<@NonNull TimeGraphEntryModel> model = response.getModel();
            if (model != null) {
                synchronized (fEntries) {
                    Object scope = (model.getScope() == null) ? dataProvider : model.getScope();
                    fProviders.put(parentTrace, dataProvider);
                    fScopes.put(parentTrace, scope);
                    /*
                     * The provider may send entries unordered and parents may
                     * not exist when child is constructor, we'll re-unite
                     * families at the end
                     */
                    List<TimeGraphEntry> orphaned = new ArrayList<>();
                    for (TimeGraphEntryModel entry : model.getEntries()) {
                        TimeGraphEntry uiEntry = fScopedEntries.get(scope, entry.getId());
                        if (entry.getParentId() != -1) {
                            if (uiEntry == null) {
                                uiEntry = new TimeGraphEntry(entry);
                                TimeGraphEntry parent = fScopedEntries.get(scope, entry.getParentId());
                                if (parent != null) {
                                    // TODO: the order of children from
                                    // different data providers is undefined
                                    parent.addChild(uiEntry);
                                } else {
                                    orphaned.add(uiEntry);
                                }
                                fScopedEntries.put(scope, entry.getId(), uiEntry);
                            } else {
                                uiEntry.updateModel(entry);
                            }
                        } else {
                            if (entry.getStartTime() != Long.MIN_VALUE) {
                                setStartTime(Long.min(getStartTime(), entry.getStartTime()));
                            }
                            setEndTime(Long.max(getEndTime(), entry.getEndTime() + 1));

                            if (uiEntry != null) {
                                uiEntry.updateModel(entry);
                            } else {
                                // Do not assume that parentless entries are
                                // trace entries
                                uiEntry = new TraceEntry(entry, trace, dataProvider);
                                fScopedEntries.put(scope, entry.getId(), uiEntry);
                                addToEntryList(parentTrace, Collections.singletonList(uiEntry));
                            }
                        }
                        fEntries.put(dataProvider, entry.getId(), uiEntry);
                        fEntryIds.put(uiEntry, dataProvider, entry.getId());
                    }
                    // Find missing parents
                    for (TimeGraphEntry orphanedEntry : orphaned) {
                        TimeGraphEntry parent = fScopedEntries.get(scope, orphanedEntry.getEntryModel().getParentId());
                        parent.addChild(orphanedEntry);
                    }
                }

                long start = getStartTime();
                long end = getEndTime();
                final long resolution = Long.max(1, (end - start) / getDisplayWidth());
                @NonNull
                Iterable<@NonNull TimeGraphEntry> entries;
                synchronized (fEntries) {
                    entries = ImmutableList.copyOf(fEntries.values());
                }
                zoomEntries(entries, start, end, resolution, monitor);
            }

            if (monitor.isCanceled()) {
                return;
            }

            if (parentTrace.equals(getTrace())) {
                synchingToTime(getTimeGraphViewer().getSelectionBegin());
                refresh();
            }
            monitor.worked(1);

            if (!complete && !monitor.isCanceled()) {
                try {
                    Thread.sleep(BUILD_UPDATE_TIMEOUT);
                } catch (InterruptedException e) {
                    Activator.getDefault().logError("Failed to wait for data provider", e); //$NON-NLS-1$
                    Thread.currentThread().interrupt();
                }
            }
        }
    }

    /**
     * Class to represent a parent entry, for which we keep a link to the trace
     * and data provider to avoid having to do so for its children. This type of
     * entry is otherwise not different from any other time graph entry.
     *
     * @author Loic Prieur-Drevon
     */
    protected static class TraceEntry extends TimeGraphEntry {
        private final @NonNull ITmfTrace fTrace;
        private final @NonNull ITimeGraphDataProvider<? extends TimeGraphEntryModel> fProvider;

        /**
         * Constructor
         *
         * @param model
         *            trace level model
         * @param trace
         *            The trace corresponding to this trace entry.
         * @param provider
         *            reference to the provider for this trace and view
         */
        public TraceEntry(@NonNull TimeGraphEntryModel model, @NonNull ITmfTrace trace,
                @NonNull ITimeGraphDataProvider<? extends TimeGraphEntryModel> provider) {
            super(model);
            fTrace = trace;
            fProvider = provider;
        }

        /**
         * Getter for this trace entry's trace
         *
         * @return the trace for this trace entry and its children
         */
        public @NonNull ITmfTrace getTrace() {
            return fTrace;
        }

        /**
         * Getter for the data provider for this {@link TraceEntry}
         *
         * @return this entry's {@link ITimeGraphDataProvider}
         */
        public @NonNull ITimeGraphDataProvider<? extends TimeGraphEntryModel> getProvider() {
            return fProvider;
        }
    }

    /**
     * Get the {@link ITmfTrace} from a {@link TimeGraphEntry}'s parent.
     *
     * @param entry
     *            queried {@link TimeGraphEntry}.
     * @return the {@link ITmfTrace}
     */
    public static @NonNull ITmfTrace getTrace(TimeGraphEntry entry) {
        return getTraceEntry(entry).getTrace();
    }

    /**
     * Get the {@link ITimeGraphDataProvider} from a {@link TimeGraphEntry}'s
     * parent.
     *
     * @param entry
     *            queried {@link TimeGraphEntry}.
     * @return the {@link ITimeGraphDataProvider}
     */
    public static ITimeGraphDataProvider<? extends TimeGraphEntryModel> getProvider(TimeGraphEntry entry) {
        TraceEntry traceEntry = getTraceEntry(entry);
        // TODO: A trace can have many providers
        return traceEntry.getProvider();
    }

    private Collection<ITimeGraphDataProvider<? extends @NonNull TimeGraphEntryModel>> getProviders(ITmfTrace viewTrace) {
        Collection<ITimeGraphDataProvider<? extends @NonNull TimeGraphEntryModel>> providers;
        synchronized (fEntries) {
            providers = fProviders.get(viewTrace);
        }
        if (!providers.isEmpty()) {
            return providers;
        }
        List<@NonNull TimeGraphEntry> traceEntries = getEntryList(viewTrace);
        if (traceEntries == null) {
            return Collections.emptyList();
        }
        providers = new ArrayList<>();
        for (TraceEntry traceEntry : Iterables.filter(traceEntries, TraceEntry.class)) {
            providers.add(traceEntry.getProvider());
        }
        return providers;
    }

    private static TraceEntry getTraceEntry(TimeGraphEntry entry) {
        ITimeGraphEntry parent = entry;
        while (parent != null) {
            if (parent instanceof TraceEntry) {
                return ((TraceEntry) parent);
            }
            parent = parent.getParent();
        }
        throw new IllegalStateException(entry + " should have a TraceEntry parent"); //$NON-NLS-1$
    }

    @Override
    protected void zoomEntries(@NonNull Iterable<@NonNull TimeGraphEntry> entries, long zoomStartTime, long zoomEndTime,
            long resolution, boolean fullSearch, @NonNull IProgressMonitor monitor) {
        if (resolution < 0) {
            // StateSystemUtils.getTimes would throw an illegal argument
            // exception.
            return;
        }

        long start = Long.min(zoomStartTime, zoomEndTime);
        long end = Long.max(zoomStartTime, zoomEndTime);
        Sampling sampling = new Sampling(start, end, resolution);
        Multimap<ITimeGraphDataProvider<? extends TimeGraphEntryModel>, Long> providersToModelIds = filterGroupEntries(entries, zoomStartTime, zoomEndTime);
        SubMonitor subMonitor = SubMonitor.convert(monitor, getClass().getSimpleName() + "#zoomEntries", providersToModelIds.size()); //$NON-NLS-1$

        for (Entry<ITimeGraphDataProvider<? extends TimeGraphEntryModel>, Collection<Long>> entry : providersToModelIds.asMap().entrySet()) {
            ITimeGraphDataProvider<? extends TimeGraphEntryModel> dataProvider = entry.getKey();
            Map<@NonNull String, @NonNull Object> parameters = getFetchRowModelParameters(start, end, resolution, fullSearch, entry.getValue());
            TmfModelResponse<TimeGraphModel> response = dataProvider.fetchRowModel(parameters, monitor);

            TimeGraphModel model = response.getModel();
            if (model != null) {
                zoomEntries(fEntries.row(dataProvider), model.getRows(), response.getStatus() == ITmfResponse.Status.COMPLETED, sampling);
            }
            subMonitor.worked(1);
        }
    }

    /**
     * Filter the entries to return only the Non Null {@link TimeGraphEntry}
     * which intersect the time range.
     *
     * @param visible
     *            the input list of visible entries
     * @param zoomStartTime
     *            the leftmost time bound of the view
     * @param zoomEndTime
     *            the rightmost time bound of the view
     * @return A Multimap of data providers to their visible entries' model IDs.
     */
    private Multimap<ITimeGraphDataProvider<? extends TimeGraphEntryModel>, Long> filterGroupEntries(
            Iterable<TimeGraphEntry> visible, long zoomStartTime, long zoomEndTime) {
        Multimap<ITimeGraphDataProvider<? extends TimeGraphEntryModel>, Long> providersToModelIds = HashMultimap.create();
        for (TimeGraphEntry entry : visible) {
            if (zoomStartTime <= entry.getEndTime() && zoomEndTime >= entry.getStartTime() && entry.hasTimeEvents()) {
                synchronized (fEntries) {
                    if (!fEntryIds.isEmpty()) {
                        fEntryIds.row(entry).forEach((provider, modelId) -> providersToModelIds.put(provider, modelId));
                    } else {
                        ITimeGraphDataProvider<? extends TimeGraphEntryModel> provider = getProvider(entry);
                        if (provider != null) {
                            providersToModelIds.put(provider, entry.getEntryModel().getId());
                        }
                    }
                }
            }
        }
        return providersToModelIds;
    }

    private void zoomEntries(Map<Long, TimeGraphEntry> map, List<ITimeGraphRowModel> model, boolean completed, Sampling sampling) {
        boolean isZoomThread = Thread.currentThread() instanceof ZoomThread;
        for (ITimeGraphRowModel rowModel : model) {
            TimeGraphEntry entry;
            synchronized (fEntries) {
                entry = map.get(rowModel.getEntryID());
            }

            if (entry != null) {
                List<ITimeEvent> events = createTimeEvents(entry, rowModel.getStates());
                if (isZoomThread) {
                    applyResults(() -> {
                        entry.setZoomedEventList(events);
                        if (completed) {
                            entry.setSampling(sampling);
                        }
                    });
                } else {
                    entry.setEventList(events);
                }
            }
        }
    }

    /**
     * Create {@link ITimeEvent}s for an entry from the list of
     * {@link ITimeGraphState}s, filling in the gaps.
     *
     * @param entry
     *            the {@link TimeGraphEntry} on which we are working
     * @param values
     *            the list of {@link ITimeGraphState}s from the
     *            {@link ITimeGraphDataProvider}.
     * @return a contiguous List of {@link ITimeEvent}s
     */
    protected List<ITimeEvent> createTimeEvents(TimeGraphEntry entry, List<ITimeGraphState> values) {
        List<ITimeEvent> events = new ArrayList<>(values.size());
        ITimeEvent prev = null;
        for (ITimeGraphState state : values) {
            ITimeEvent event = createTimeEvent(entry, state);
            if (prev != null) {
                long prevEnd = prev.getTime() + prev.getDuration();
                if (prevEnd < event.getTime() && (getTimeEventFilterDialog() == null
                        || !getTimeEventFilterDialog().hasActiveSavedFilters())) {
                    // fill in the gap.
                    TimeEvent timeEvent = new TimeEvent(entry, prevEnd, event.getTime() - prevEnd);
                    if (getTimeEventFilterDialog() != null && getTimeEventFilterDialog().isFilterActive()) {
                        timeEvent.setProperty(CoreFilterProperty.DIMMED, true);
                    }
                    events.add(timeEvent);
                }
            }
            prev = event;
            events.add(event);
        }
        return events;
    }

    /**
     * Create a {@link TimeEvent} for a {@link TimeGraphEntry} and a
     * {@link TimeGraphState}
     *
     * @param entry
     *            {@link TimeGraphEntry} for which we create a state
     * @param state
     *            {@link ITimeGraphState} from the data provider
     * @return a new {@link TimeEvent} for these arguments
     */
    protected TimeEvent createTimeEvent(TimeGraphEntry entry, ITimeGraphState state) {
        String label = state.getLabel();
        if (state.getValue() == Integer.MIN_VALUE && label == null && state.getStyle() == null) {
            return new NullTimeEvent(entry, state.getStartTime(), state.getDuration());
        }
        if (label != null) {
            return new NamedTimeEvent(entry, label, state);
        }
        return new TimeEvent(entry, state);
    }

    @Override
    protected List<@NonNull ILinkEvent> getLinkList(long zoomStartTime, long zoomEndTime, long resolution,
            @NonNull IProgressMonitor monitor) {
        Collection<ITimeGraphDataProvider<? extends @NonNull TimeGraphEntryModel>> providers = getProviders(getTrace());
        if (providers.isEmpty()) {
            return Collections.emptyList();
        }
        List<@NonNull ILinkEvent> linkList = new ArrayList<>();
        List<@NonNull Long> times = StateSystemUtils.getTimes(zoomStartTime, zoomEndTime, resolution);
        Map<@NonNull String, @NonNull Object> parameters = getFetchArrowsParameters(times);

        for (ITimeGraphDataProvider<? extends TimeGraphEntryModel> provider : providers) {
            TmfModelResponse<List<ITimeGraphArrow>> response = provider.fetchArrows(parameters, monitor);
            List<ITimeGraphArrow> model = response.getModel();

            if (model != null) {
                for (ITimeGraphArrow arrow : model) {
                    ITimeGraphEntry prevEntry;
                    ITimeGraphEntry nextEntry;
                    synchronized (fEntries) {
                        prevEntry = fEntries.get(provider, arrow.getSourceId());
                        nextEntry = fEntries.get(provider, arrow.getDestinationId());
                    }
                    if (prevEntry != null && nextEntry != null) {
                        linkList.add(new TimeLinkEvent(arrow, prevEntry, nextEntry));
                    }
                }
            }
        }
        return linkList;
    }

    @Override
    protected @NonNull List<String> getViewMarkerCategories() {
        List<String> viewerMarkerCategories = super.getViewMarkerCategories();
        Collection<ITimeGraphDataProvider<? extends @NonNull TimeGraphEntryModel>> providers = getProviders(getTrace());
        if (providers.isEmpty()) {
            return viewerMarkerCategories;
        }
        for (ITimeGraphDataProvider<? extends TimeGraphEntryModel> provider : providers) {
            if (provider instanceof IOutputAnnotationProvider) {
                Map<@NonNull String, @NonNull Object> parameters = getFetchAnnotationCategoriesParameters();
                TmfModelResponse<@NonNull AnnotationCategoriesModel> response = ((IOutputAnnotationProvider) provider)
                        .fetchAnnotationCategories(parameters, new NullProgressMonitor());
                AnnotationCategoriesModel model = response.getModel();
                if (model != null) {
                    viewerMarkerCategories.addAll(model.getAnnotationCategories());
                }
            }
        }
        return viewerMarkerCategories;
    }

    @Override
    protected @NonNull List<IMarkerEvent> getViewMarkerList(long startTime, long endTime, long resolution,
            @NonNull IProgressMonitor monitor) {
        List<IMarkerEvent> viewerMarkerList = super.getViewMarkerList(startTime, endTime, resolution, monitor);
        List<@NonNull TimeGraphEntry> traceEntries = getEntryList(getTrace());
        if (traceEntries == null) {
            return viewerMarkerList;
        }
        List<@NonNull Long> times = StateSystemUtils.getTimes(startTime, endTime, resolution);
        for (TraceEntry traceEntry : Iterables.filter(traceEntries, TraceEntry.class)) {
            Multimap<ITimeGraphDataProvider<? extends TimeGraphEntryModel>, Long> providersToModelIds = filterGroupEntries(Utils.flatten(traceEntry), startTime, endTime);
            for (ITimeGraphDataProvider<? extends TimeGraphEntryModel> provider : providersToModelIds.keySet()) {
                if (provider instanceof IOutputAnnotationProvider) {
                    Map<@NonNull String, @NonNull Object> parameters = getFetchAnnotationsParameters(times, providersToModelIds.get(provider));
                    TmfModelResponse<@NonNull AnnotationModel> response = ((IOutputAnnotationProvider) provider).fetchAnnotations(parameters, new NullProgressMonitor());
                    AnnotationModel model = response.getModel();
                    if (model != null) {
                        for (Entry<String, Collection<Annotation>> entry : model.getAnnotations().entrySet()) {
                            String category = entry.getKey();
                            for (Annotation annotation : entry.getValue()) {
                                if (annotation.getType() == AnnotationType.CHART) {
                                    // If the annotation entry ID is -1 we want
                                    // the
                                    // marker to span across all entries
                                    ITimeGraphEntry markerEntry = null;
                                    if (annotation.getEntryId() != -1) {
                                        synchronized (fEntries) {
                                            markerEntry = fEntries.get(provider, annotation.getEntryId());
                                        }
                                    }
                                    MarkerEvent markerEvent = new MarkerEvent(annotation, markerEntry, category, true);
                                    viewerMarkerList.add(markerEvent);
                                }
                            }
                        }
                    }
                }
            }
        }
        return viewerMarkerList;
    }

    /**
     * Get the fetch parameters to pass to a fetchTree call
     *
     * @return Map of parameters for fetchTree
     */
    protected @NonNull Map<@NonNull String, @NonNull Object> getFetchTreeParameters() {
        return new HashMap<>();
    }

    /**
     * Get the fetch parameters to pass to a fetchRowModel call
     *
     * @param start
     *            Start time of query
     * @param end
     *            End time of query
     * @param resolution
     *            Resolution of query
     * @param fullSearch
     *            True to perform a full search
     * @param items
     *            The unique keys of the entries to query.
     * @return Map of parameters for fetchRowModel
     */
    protected @NonNull Map<@NonNull String, @NonNull Object> getFetchRowModelParameters(long start, long end,
            long resolution, boolean fullSearch, @NonNull Collection<@NonNull Long> items) {
        @NonNull
        Map<@NonNull String, @NonNull Object> parameters = new HashMap<>();
        parameters.put(DataProviderParameterUtils.REQUESTED_TIME_KEY, StateSystemUtils.getTimes(start, end, resolution));
        parameters.put(DataProviderParameterUtils.REQUESTED_ITEMS_KEY, items);
        Multimap<@NonNull Integer, @NonNull String> regexesMap = getRegexes();
        if (!regexesMap.isEmpty()) {
            parameters.put(DataProviderParameterUtils.REGEX_MAP_FILTERS_KEY, regexesMap.asMap());
        }
        if (fullSearch) {
            parameters.put(DataProviderParameterUtils.FULL_SEARCH_KEY, Boolean.TRUE);
        }
        return parameters;
    }

    /**
     * Get the fetch parameters to pass to a fetchArrows call
     *
     * @param times
     *            Sorted list of times to query.
     * @return Map of parameters for fetchArrows
     */
    protected @NonNull Map<@NonNull String, @NonNull Object> getFetchArrowsParameters(@NonNull List<@NonNull Long> times) {
        @NonNull
        Map<@NonNull String, @NonNull Object> parameters = new HashMap<>();
        parameters.put(DataProviderParameterUtils.REQUESTED_TIME_KEY, times);
        return parameters;
    }

    /**
     * Get the fetch parameters to pass to a fetchTooltip call
     *
     * @param time
     *            The time of the tooltip.
     * @param item
     *            The unique key of the tooltip entry.
     * @param element
     *            The model element of the tooltip.
     * @return Map of parameters for fetchTooltip
     */
    protected @NonNull Map<@NonNull String, @NonNull Object> getFetchTooltipParameters(long time, long item, @Nullable IOutputElement element) {
        @NonNull
        Map<@NonNull String, @NonNull Object> parameters = new HashMap<>();
        parameters.put(DataProviderParameterUtils.REQUESTED_TIME_KEY, Collections.singletonList(time));
        parameters.put(DataProviderParameterUtils.REQUESTED_ITEMS_KEY, Collections.singletonList(item));
        if (element != null) {
            parameters.put(DataProviderParameterUtils.REQUESTED_ELEMENT_KEY, element);
        }
        return parameters;
    }

    /**
     * Get the fetch parameters to pass to a fetchAnnotationCategories call
     *
     * @return Map of parameters for fetchAnnotationCategories
     */
    protected @NonNull Map<@NonNull String, @NonNull Object> getFetchAnnotationCategoriesParameters() {
        return new HashMap<>();
    }

    /**
     * Get the fetch parameters to pass to a fetchAnnotations call
     *
     * @param times
     *            Sorted list of times to query.
     * @param items
     *            The unique keys of the entries to query.
     * @return Map of parameters for fetchAnnotations
     */
    protected @NonNull Map<@NonNull String, @NonNull Object> getFetchAnnotationsParameters(
            @NonNull List<Long> times, @NonNull Collection<Long> items) {
        @NonNull
        Map<@NonNull String, @NonNull Object> parameters = new HashMap<>();
        parameters.put(DataProviderParameterUtils.REQUESTED_TIME_KEY, times);
        parameters.put(DataProviderParameterUtils.REQUESTED_ITEMS_KEY, items);
        return parameters;
    }

    private BiFunction<ITimeEvent, Long, Map<String, String>> getTooltipResolver(
            ITimeGraphDataProvider<? extends TimeGraphEntryModel> provider) {
        return (event, time) -> {
            Long entryId = null;
            synchronized (fEntries) {
                entryId = fEntryIds.get(event.getEntry(), provider);
            }
            if (entryId == null) {
                return Collections.emptyMap();
            }
            IOutputElement element = null;
            if (event instanceof TimeEvent) {
                element = ((TimeEvent) event).getModel();
            }
            Map<@NonNull String, @NonNull Object> parameters = getFetchTooltipParameters(time, entryId, element);
            TmfModelResponse<Map<String, String>> response = provider.fetchTooltip(parameters, new NullProgressMonitor());
            Map<String, String> tooltip = response.getModel();
            return (tooltip == null) ? Collections.emptyMap() : tooltip;
        };
    }

    @Override
    protected void resetViewer(ITmfTrace viewTrace) {
        List<@NonNull TimeGraphEntry> entryList = getEntryList(viewTrace);
        super.resetViewer(viewTrace);
        // Remove the entries for this trace
        if (entryList != null) {
            synchronized (fEntries) {
                if (!fProviders.isEmpty()) {
                    fProviders.removeAll(viewTrace).forEach(provider -> {
                        fEntries.row(provider).clear();
                        fEntryIds.column(provider).clear();
                    });
                } else {
                    for (TimeGraphEntry entry : entryList) {
                        if (entry instanceof TraceEntry) {
                            fEntries.row(((TraceEntry) entry).getProvider()).clear();
                        }
                    }
                }
                fScopes.removeAll(viewTrace).forEach(scope -> fScopedEntries.row(scope).clear());
            }
        }
    }

    private IContributionItem createOpenSourceCodeAction(Map<String, String> model) {
        if (model != null) {
            String callsite = model.get(TmfStrings.source());
            return OpenSourceCodeAction.create(Messages.BaseDataProviderTimeGraphMultiViewer_OpenSourceActionName, () -> {
                if (callsite != null) {
                    Matcher matcher = SOURCE_REGEX.matcher(callsite);
                    if (matcher.matches()) {
                        return new TmfCallsite(Objects.requireNonNull(matcher.group(1)), Long.parseLong(matcher.group(2)));
                    }
                }
                return null;
            }, this.getTimeGraphViewer().getTimeGraphControl().getShell());
        }
        return null;
    }

    /**
     * Fill context menu
     *
     * @param menuManager
     *            a menuManager to fill
     */
    protected void fillTimeEventContextMenu(@NonNull IMenuManager menuManager) {
        ISelection selection = getSite().getSelectionProvider().getSelection();
        if (selection instanceof IStructuredSelection) {
            IStructuredSelection sSel = (IStructuredSelection) selection;
            Object firstElement = sSel.getFirstElement();
            if (firstElement instanceof TimeGraphEntry) {
                Object entryObject = sSel.toArray()[1];
                if (entryObject instanceof TimeEvent) {
                    TimeEvent event = (TimeEvent) entryObject;
                    IContributionItem contribItem = createOpenSourceCodeAction(getPresentationProvider().getEventHoverToolTipInfo(event, getTimeGraphViewer().getSelectionBegin()));
                    if (contribItem != null) {
                        menuManager.add(contribItem);
                    }
                }
            }
        }
    }

    private void createTimeEventContextMenu() {
        MenuManager eventMenuManager = new MenuManager();
        eventMenuManager.setRemoveAllWhenShown(true);
        TimeGraphControl timeGraphControl = getTimeGraphViewer().getTimeGraphControl();
        final Menu timeEventMenu = eventMenuManager.createContextMenu(timeGraphControl);

        timeGraphControl.addTimeEventMenuListener(event -> {
            Menu menu = timeEventMenu;
            if (event.data instanceof TimeEvent) {
                timeGraphControl.setMenu(menu);
                return;
            }
            timeGraphControl.setMenu(null);
            event.doit = false;
        });

        eventMenuManager.addMenuListener(manager -> {
            fillTimeEventContextMenu(eventMenuManager);
            eventMenuManager.add(new GroupMarker(IWorkbenchActionConstants.MB_ADDITIONS));
        });
        getSite().registerContextMenu(eventMenuManager, getTimeGraphViewer().getSelectionProvider());
    }

}