Examples with ITimeGraphPresentationProvider org.eclipse.tracecompass.tmf.ui.widgets.timegraph.ITimeGraphPresentationProvider used on opensource projects

Example 1 with ITimeGraphPresentationProvider

use of org.eclipse.tracecompass.tmf.ui.widgets.timegraph.ITimeGraphPresentationProvider in project tracecompass by tracecompass.

the class AbstractTimeGraphView method createPartControl.

// ------------------------------------------------------------------------
// ViewPart
// ------------------------------------------------------------------------
@Override
public void createPartControl(Composite parent) {
    super.createPartControl(parent);
    TimeGraphViewer timeGraphViewer = new TimeGraphViewer(parent, SWT.NONE);
    fTimeGraphViewer = timeGraphViewer;
    if (fLabelProvider != null) {
        timeGraphViewer.setTimeGraphLabelProvider(fLabelProvider);
    }
    if (fLegendProvider != null) {
        timeGraphViewer.setLegendProvider(fLegendProvider);
    }
    if (fColumns != null) {
        timeGraphViewer.setColumns(fColumns);
        if (fColumnComparators != null) {
            createColumnSelectionListener(timeGraphViewer.getTree());
        }
    }
    timeGraphViewer.setTimeGraphContentProvider(fTimeGraphContentProvider);
    timeGraphViewer.setFilterContentProvider(fFilterContentProvider != null ? fFilterContentProvider : fTimeGraphContentProvider);
    timeGraphViewer.setFilterLabelProvider(fFilterLabelProvider);
    timeGraphViewer.setFilterColumns(fFilterColumns);
    timeGraphViewer.addSelectionListener(fMetadataSelectionListener);
    ITimeGraphPresentationProvider presentationProvider = getPresentationProvider();
    timeGraphViewer.setTimeGraphProvider(presentationProvider);
    presentationProvider.addColorListener(stateItems -> TimeGraphStyleUtil.loadValues(getPresentationProvider()));
    presentationProvider.refresh();
    timeGraphViewer.setAutoExpandLevel(fAutoExpandLevel);
    timeGraphViewer.setWeights(fWeight);
    TimeGraphControl timeGraphControl = timeGraphViewer.getTimeGraphControl();
    Action timeEventFilterAction = new Action() {

        @Override
        public void run() {
            int xCoord = timeGraphControl.toControl(timeGraphControl.getDisplay().getCursorLocation()).x;
            if ((timeGraphViewer.getNameSpace() < xCoord) && (xCoord < timeGraphControl.getSize().x)) {
                if (fTimeEventFilterDialog != null) {
                    fTimeEventFilterDialog.close();
                    fTimeEventFilterDialog = null;
                }
                fTimeEventFilterDialog = new TimeEventFilterDialog(timeGraphControl.getShell(), AbstractTimeGraphView.this, getTimeGraphViewer().getTimeGraphControl());
                fTimeEventFilterDialog.open();
            }
        }
    };
    fTimeEventFilterAction = timeEventFilterAction;
    timeGraphViewer.addRangeListener(event -> {
        final long startTime = event.getStartTime();
        final long endTime = event.getEndTime();
        TmfTimeRange range = new TmfTimeRange(TmfTimestamp.fromNanos(startTime), TmfTimestamp.fromNanos(endTime));
        broadcast(new TmfWindowRangeUpdatedSignal(AbstractTimeGraphView.this, range, fTrace));
        startZoomThread(startTime, endTime);
    });
    timeGraphViewer.addTimeListener(event -> {
        ITmfTimestamp startTime = TmfTimestamp.fromNanos(event.getBeginTime());
        ITmfTimestamp endTime = TmfTimestamp.fromNanos(event.getEndTime());
        broadcast(new TmfSelectionRangeUpdatedSignal(AbstractTimeGraphView.this, startTime, endTime, fTrace));
    });
    timeGraphViewer.addBookmarkListener(new ITimeGraphBookmarkListener() {

        @Override
        public void bookmarkAdded(final TimeGraphBookmarkEvent event) {
            try {
                ResourcesPlugin.getWorkspace().run(new IWorkspaceRunnable() {

                    @Override
                    public void run(IProgressMonitor monitor) throws CoreException {
                        IMarkerEvent bookmark = event.getBookmark();
                        IFile editorFile = fEditorFile;
                        if (editorFile == null) {
                            return;
                        }
                        IMarker marker = editorFile.createMarker(IMarker.BOOKMARK);
                        marker.setAttribute(IMarker.MESSAGE, bookmark.getLabel());
                        marker.setAttribute(ITmfMarker.MARKER_TIME, Long.toString(bookmark.getTime()));
                        if (bookmark.getDuration() > 0) {
                            marker.setAttribute(ITmfMarker.MARKER_DURATION, Long.toString(bookmark.getDuration()));
                            marker.setAttribute(IMarker.LOCATION, NLS.bind(org.eclipse.tracecompass.internal.tmf.ui.Messages.TmfMarker_LocationTimeRange, TmfTimestamp.fromNanos(bookmark.getTime()), TmfTimestamp.fromNanos(bookmark.getTime() + bookmark.getDuration())));
                        } else {
                            marker.setAttribute(IMarker.LOCATION, NLS.bind(org.eclipse.tracecompass.internal.tmf.ui.Messages.TmfMarker_LocationTime, TmfTimestamp.fromNanos(bookmark.getTime())));
                        }
                        marker.setAttribute(ITmfMarker.MARKER_COLOR, bookmark.getColor().toString());
                    }
                }, null);
            } catch (CoreException e) {
                Activator.getDefault().logError(e.getMessage());
            }
        }

        @Override
        public void bookmarkRemoved(TimeGraphBookmarkEvent event) {
            try {
                IMarkerEvent bookmark = event.getBookmark();
                IFile editorFile = fEditorFile;
                if (editorFile == null) {
                    return;
                }
                IMarker[] markers = editorFile.findMarkers(IMarker.BOOKMARK, false, IResource.DEPTH_ZERO);
                for (IMarker marker : markers) {
                    if (bookmark.getLabel().equals(marker.getAttribute(IMarker.MESSAGE)) && Long.toString(bookmark.getTime()).equals(marker.getAttribute(ITmfMarker.MARKER_TIME, (String) null)) && Long.toString(bookmark.getDuration()).equals(marker.getAttribute(ITmfMarker.MARKER_DURATION, Long.toString(0))) && bookmark.getColor().toString().equals(marker.getAttribute(ITmfMarker.MARKER_COLOR))) {
                        marker.delete();
                        break;
                    }
                }
            } catch (CoreException e) {
                Activator.getDefault().logError(e.getMessage());
            }
        }
    });
    fTimeGraphViewer.addMarkerListener(() -> restartZoomThread());
    timeGraphControl.addPaintListener(new PaintListener() {

        /**
         * This paint control allows the virtual time graph refresh to occur on paint
         * events instead of just scrolling the time axis or zooming. To avoid
         * refreshing the model on every paint event, we use a TmfUiRefreshHandler to
         * coalesce requests and only execute the last one, we also check if the entries
         * have changed to avoid useless model refresh.
         *
         * @param e
         *            paint event on the visible area
         */
        @Override
        public void paintControl(PaintEvent e) {
            TmfUiRefreshHandler.getInstance().queueUpdate(this, () -> {
                if (timeGraphControl.isDisposed()) {
                    return;
                }
                int timeSpace = getTimeGraphViewer().getTimeSpace();
                Set<@NonNull TimeGraphEntry> newSet = getVisibleItems(DEFAULT_BUFFER_SIZE);
                if (fPrevTimeSpace != timeSpace || !fVisibleEntries.equals(newSet)) {
                    /*
                         * Start a zoom thread if the set of visible entries has changed. We do not use
                         * lists as the order is not important. We cannot use the start index / size of
                         * the visible entries as we can collapse / reorder events.
                         */
                    fVisibleEntries = newSet;
                    fPrevTimeSpace = timeSpace;
                    startZoomThread(getTimeGraphViewer().getTime0(), getTimeGraphViewer().getTime1());
                }
            });
        }
    });
    IStatusLineManager statusLineManager = getViewSite().getActionBars().getStatusLineManager();
    timeGraphControl.setStatusLineManager(statusLineManager);
    // View Action Handling
    makeActions();
    contributeToActionBars();
    ITmfTrace trace = TmfTraceManager.getInstance().getActiveTrace();
    if (trace != null) {
        traceSelected(new TmfTraceSelectedSignal(this, trace));
    }
    // make selection available to other views
    IWorkbenchPartSite site = getSite();
    site.setSelectionProvider(timeGraphViewer.getSelectionProvider());
    ResourcesPlugin.getWorkspace().addResourceChangeListener(this, IResourceChangeEvent.POST_CHANGE);
    createContextMenu();
    fPartListener = new TimeGraphPartListener();
    site.getPage().addPartListener(fPartListener);
    fPartListener2 = new TimeGraphPartListener2();
    site.getPage().addPartListener(fPartListener2);
    fOriginalTabLabel = getPartName();
    fContextService = site.getWorkbenchWindow().getService(IContextService.class);
    if (timeGraphControl.isInFocus()) {
        activateContextService();
    }
    timeGraphControl.addFocusListener(new FocusListener() {

        @Override
        public void focusLost(FocusEvent e) {
            deactivateContextService();
        }

        @Override
        public void focusGained(FocusEvent e) {
            activateContextService();
        }
    });
    updateTimeFormat();
}

Example 2 with ITimeGraphPresentationProvider

use of org.eclipse.tracecompass.tmf.ui.widgets.timegraph.ITimeGraphPresentationProvider in project tracecompass by tracecompass.

the class XmlTimeGraphView method buildEntryList.

// ------------------------------------------------------------------------
// Internal
// ------------------------------------------------------------------------
@Override
protected void buildEntryList(ITmfTrace trace, ITmfTrace parentTrace, IProgressMonitor monitor) {
    /*
         * Get the view element from the XML file. If the element can't be found,
         * return.
         */
    Element viewElement = fViewInfo.getViewElement(TmfXmlStrings.TIME_GRAPH_VIEW);
    if (viewElement == null) {
        return;
    }
    // Empty the additional state values
    fStringValueMap.clear();
    ITimeGraphPresentationProvider pres = this.getPresentationProvider();
    if (pres instanceof XmlPresentationProvider) {
        /*
             * TODO: Each entry of a line could have their own states/color. That will
             * require an update to the presentation provider
             */
        ((XmlPresentationProvider) pres).loadNewStates(viewElement);
        Display.getDefault().asyncExec(() -> {
            TimeGraphViewer timeGraphViewer = getTimeGraphViewer();
            if (timeGraphViewer.getTimeGraphControl().isDisposed()) {
                return;
            }
            timeGraphViewer.getTimeGraphControl().colorSettingsChanged(timeGraphViewer.getTimeGraphProvider().getStateTable());
        });
    }
    String title = fViewInfo.getViewTitle(viewElement);
    setViewTitle(title != null ? title : Messages.XmlTimeGraphView_DefaultTitle);
    SubMonitor subMonitor = SubMonitor.convert(monitor);
    boolean complete = false;
    ITimeGraphDataProvider<@NonNull TimeGraphEntryModel> provider = XmlDataProviderManager.getInstance().getTimeGraphProvider(trace, viewElement);
    if (provider == null) {
        return;
    }
    while (!complete && !subMonitor.isCanceled()) {
        TmfModelResponse<TmfTreeModel<@NonNull TimeGraphEntryModel>> response = provider.fetchTree(FetchParametersUtils.timeQueryToMap(new TimeQueryFilter(0, Long.MAX_VALUE, 2)), subMonitor);
        if (response.getStatus() == ITmfResponse.Status.FAILED) {
            // $NON-NLS-1$
            Activator.logError("XML Time Graph Data Provider failed: " + response.getStatusMessage());
            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) {
                /*
                     * Ensure that all the entries exist and are up to date.
                     */
                for (TimeGraphEntryModel entry : model.getEntries()) {
                    TimeGraphEntry tgEntry = fEntries.get(provider, entry.getId());
                    if (tgEntry == null) {
                        if (entry.getParentId() == -1) {
                            tgEntry = new TraceEntry(entry, trace, provider);
                            addToEntryList(parentTrace, Collections.singletonList(tgEntry));
                        } else {
                            tgEntry = new TimeGraphEntry(entry);
                        }
                        fEntries.put(provider, entry.getId(), tgEntry);
                    } else {
                        tgEntry.updateModel(entry);
                    }
                    if (entry.getParentId() == -1) {
                        setStartTime(Long.min(getStartTime(), entry.getStartTime()));
                        setEndTime(Long.max(getEndTime(), entry.getEndTime()));
                    }
                }
            }
            /*
                 * set the correct child / parent relation
                 */
            for (TimeGraphEntry child : fEntries.row(provider).values()) {
                TimeGraphEntry parent = fEntries.get(provider, child.getEntryModel().getParentId());
                if (parent != null) {
                    parent.addChild(child);
                }
            }
            long start = getStartTime();
            long end = getEndTime();
            final long resolution = Long.max(1, (end - start) / getDisplayWidth());
            zoomEntries(fEntries.row(provider).values(), start, end, resolution, subMonitor);
        }
        if (parentTrace.equals(getTrace())) {
            refresh();
        }
        subMonitor.worked(1);
        if (!complete) {
            try {
                Thread.sleep(BUILD_UPDATE_TIMEOUT);
            } catch (InterruptedException e) {
                // $NON-NLS-1$
                Activator.logError("Failed to wait for data provider", e);
            }
        }
    }
}

Example 3 with ITimeGraphPresentationProvider

use of org.eclipse.tracecompass.tmf.ui.widgets.timegraph.ITimeGraphPresentationProvider in project tracecompass by tracecompass.

the class BaseDataProviderTimeGraphView method buildEntryList.

@Override
protected void buildEntryList(@NonNull ITmfTrace trace, @NonNull ITmfTrace parentTrace, @NonNull IProgressMonitor monitor) {
    ITimeGraphDataProvider<@NonNull TimeGraphEntryModel> dataProvider = DataProviderManager.getInstance().getDataProvider(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) {
            // $NON-NLS-1$
            Activator.getDefault().logError(getClass().getSimpleName() + " Data Provider failed: " + response.getStatusMessage());
            return;
        } else if (response.getStatus() == ITmfResponse.Status.CANCELLED) {
            return;
        }
        complete = response.getStatus() == ITmfResponse.Status.COMPLETED;
        double factor = 1.0;
        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<>();
                Map<Long, AtomicInteger> indexMap = new HashMap<>();
                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
                                int index = indexMap.computeIfAbsent(entry.getParentId(), l -> new AtomicInteger()).getAndIncrement();
                                parent.addChild(index, uiEntry);
                            } else {
                                orphaned.add(uiEntry);
                            }
                            fScopedEntries.put(scope, entry.getId(), uiEntry);
                        } else {
                            indexMap.computeIfAbsent(entry.getParentId(), l -> new AtomicInteger()).getAndIncrement();
                            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
                // Orphans should be inserted before non-orphans
                indexMap.clear();
                for (TimeGraphEntry orphanedEntry : orphaned) {
                    TimeGraphEntry parent = fScopedEntries.get(scope, orphanedEntry.getEntryModel().getParentId());
                    if (parent != null) {
                        int index = indexMap.computeIfAbsent(parent.getEntryModel().getId(), l -> new AtomicInteger()).getAndIncrement();
                        parent.addChild(index, 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((long) (BUILD_UPDATE_TIMEOUT * factor));
                factor = Math.min(20, factor + 1);
            } catch (InterruptedException e) {
                // $NON-NLS-1$
                Activator.getDefault().logError("Failed to wait for data provider", e);
                Thread.currentThread().interrupt();
            }
        }
    }
}