Examples with TmfCollapseFilter org.eclipse.tracecompass.internal.tmf.core.filter.TmfCollapseFilter used on opensource projects

Example 1 with TmfCollapseFilter

use of org.eclipse.tracecompass.internal.tmf.core.filter.TmfCollapseFilter in project tracecompass by tracecompass.

the class TmfEventsCache method getFilteredEventIndex.

/**
 * Get the cache index of an event from his rank in the trace. This will
 * take in consideration any filter that might be applied.
 *
 * @param rank
 *            The rank of the event in the trace
 * @return The position (index) this event should use once cached
 */
public int getFilteredEventIndex(final long rank) {
    int current;
    int startRank;
    TmfEventRequest request;
    final ITmfFilter filter = fFilter;
    synchronized (this) {
        int start = 0;
        int end = fFilterIndex.size();
        if ((fCacheEndIndex - fCacheStartIndex) > 1) {
            if (rank < fCache[0].rank) {
                end = (fCacheStartIndex / fCacheSize) + 1;
            } else if (rank > fCache[fCacheEndIndex - fCacheStartIndex - 1].rank) {
                start = fCacheEndIndex / fCacheSize;
            } else {
                for (int i = 0; i < (fCacheEndIndex - fCacheStartIndex); i++) {
                    if (fCache[i].rank >= rank) {
                        return fCacheStartIndex + i;
                    }
                }
                return fCacheEndIndex;
            }
        }
        current = (start + end) / 2;
        while (current != start) {
            if (rank < fFilterIndex.get(current)) {
                end = current;
                current = (start + end) / 2;
            } else {
                start = current;
                current = (start + end) / 2;
            }
        }
        startRank = fFilterIndex.isEmpty() ? 0 : fFilterIndex.get(current);
    }
    final int index = current * fCacheSize;
    class DataRequest extends TmfEventRequest {

        ITmfFilter requestFilter;

        TmfCollapseFilter requestCollapsedFilter;

        int requestRank;

        int requestIndex;

        DataRequest(Class<? extends ITmfEvent> dataType, ITmfFilter reqFilter, int start, int nbRequested) {
            super(dataType, TmfTimeRange.ETERNITY, start, nbRequested, TmfEventRequest.ExecutionType.FOREGROUND);
            requestFilter = reqFilter;
            requestRank = start;
            requestIndex = index;
            requestCollapsedFilter = fCollapseFilterEnabled ? new TmfCollapseFilter() : null;
        }

        @Override
        public void handleData(ITmfEvent event) {
            super.handleData(event);
            if (isCancelled()) {
                return;
            }
            if (requestRank >= rank) {
                cancel();
                return;
            }
            requestRank++;
            if (requestFilter.matches(event)) {
                if (requestCollapsedFilter == null || requestCollapsedFilter.matches(event)) {
                    requestIndex++;
                }
            }
        }

        public int getFilteredIndex() {
            return requestIndex;
        }
    }
    request = new DataRequest(ITmfEvent.class, filter, startRank, ITmfEventRequest.ALL_DATA);
    ((ITmfEventProvider) fTrace).sendRequest(request);
    try {
        request.waitForCompletion();
        return ((DataRequest) request).getFilteredIndex();
    } catch (InterruptedException e) {
        // $NON-NLS-1$
        Activator.getDefault().logError("Filter request interrupted!", e);
        Thread.currentThread().interrupt();
    }
    return 0;
}

Example 2 with TmfCollapseFilter

use of org.eclipse.tracecompass.internal.tmf.core.filter.TmfCollapseFilter in project tracecompass by tracecompass.

the class TmfEventsTable method createPopupMenu.

// ------------------------------------------------------------------------
// Operations
// ------------------------------------------------------------------------
/**
 * Create a pop-up menu.
 */
private void createPopupMenu() {
    final IAction copyAction = new Action(Messages.TmfEventsTable_CopyToClipboardActionText) {

        @Override
        public void run() {
            ITmfTrace trace = fTrace;
            if (trace == null || (fSelectedRank == -1 && fSelectedBeginRank == -1)) {
                return;
            }
            List<TmfEventTableColumn> columns = new ArrayList<>();
            for (int i : fTable.getColumnOrder()) {
                TableColumn column = fTable.getColumns()[i];
                // Omit the margin column and hidden columns
                if (isVisibleEventColumn(column)) {
                    columns.add(fColumns.get(i));
                }
            }
            long start = Math.min(fSelectedBeginRank, fSelectedRank);
            long end = Math.max(fSelectedBeginRank, fSelectedRank);
            final ITmfFilter filter = (ITmfFilter) fTable.getData(Key.FILTER_OBJ);
            IRunnableWithProgress operation = new CopyToClipboardOperation(trace, filter, columns, start, end);
            try {
                PlatformUI.getWorkbench().getProgressService().busyCursorWhile(operation);
            } catch (InvocationTargetException e) {
                // $NON-NLS-1$
                Activator.getDefault().logError("Invocation target exception copying to clipboard ", e);
            } catch (InterruptedException e) {
                Thread.currentThread().interrupt();
            }
        }
    };
    final IAction showTableAction = new Action(Messages.TmfEventsTable_ShowTableActionText) {

        @Override
        public void run() {
            fTableComposite.setVisible(true);
            fSashForm.layout();
        }
    };
    final IAction hideTableAction = new Action(Messages.TmfEventsTable_HideTableActionText) {

        @Override
        public void run() {
            fTableComposite.setVisible(false);
            fSashForm.layout();
        }
    };
    final IAction showRawAction = new Action(Messages.TmfEventsTable_ShowRawActionText) {

        @Override
        public void run() {
            fRawViewer.setVisible(true);
            fSashForm.layout();
            final int index = fTable.getSelectionIndex();
            if (index >= 1) {
                fRawViewer.selectAndReveal(index - 1);
            }
        }
    };
    final IAction hideRawAction = new Action(Messages.TmfEventsTable_HideRawActionText) {

        @Override
        public void run() {
            fRawViewer.setVisible(false);
            fSashForm.layout();
        }
    };
    final IAction openModelAction = new Action(Messages.TmfEventsTable_OpenModelActionText) {

        @Override
        public void run() {
            final TableItem[] items = fTable.getSelection();
            if (items.length != 1) {
                return;
            }
            final TableItem item = items[0];
            final Object eventData = item.getData();
            if (eventData instanceof ITmfModelLookup) {
                String modelURI = ((ITmfModelLookup) eventData).getModelUri();
                if (modelURI != null) {
                    IWorkbenchPage activePage = PlatformUI.getWorkbench().getActiveWorkbenchWindow().getActivePage();
                    IFile file = null;
                    final URI uri = URI.createURI(modelURI);
                    if (uri.isPlatformResource()) {
                        IPath path = new Path(uri.toPlatformString(true));
                        file = ResourcesPlugin.getWorkspace().getRoot().getFile(path);
                    } else if (uri.isFile() && !uri.isRelative()) {
                        file = ResourcesPlugin.getWorkspace().getRoot().getFileForLocation(new Path(uri.toFileString()));
                    }
                    if (file != null) {
                        try {
                            /*
                                 * create a temporary validation marker on the
                                 * model file, remove it afterwards thus,
                                 * navigation works with all model editors
                                 * supporting the navigation to a marker
                                 */
                            IMarker marker = file.createMarker(EValidator.MARKER);
                            marker.setAttribute(EValidator.URI_ATTRIBUTE, modelURI);
                            marker.setAttribute(IMarker.SEVERITY, IMarker.SEVERITY_INFO);
                            IDE.openEditor(activePage, marker, OpenStrategy.activateOnOpen());
                            marker.delete();
                        } catch (CoreException e) {
                            TraceUtils.displayErrorMsg(e);
                        }
                    } else {
                        final Exception e = new FileNotFoundException('\'' + modelURI + '\'' + '\n' + Messages.TmfEventsTable_OpenModelUnsupportedURI);
                        TraceUtils.displayErrorMsg(e);
                    }
                }
            }
        }
    };
    final IAction exportToTextAction = new Action(Messages.TmfEventsTable_Export_to_text) {

        @Override
        public void run() {
            IWorkbenchPage activePage = PlatformUI.getWorkbench().getActiveWorkbenchWindow().getActivePage();
            Object handlerServiceObject = activePage.getActiveEditor().getSite().getService(IHandlerService.class);
            IHandlerService handlerService = (IHandlerService) handlerServiceObject;
            Object cmdServiceObject = activePage.getActiveEditor().getSite().getService(ICommandService.class);
            ICommandService cmdService = (ICommandService) cmdServiceObject;
            try {
                HashMap<String, Object> parameters = new HashMap<>();
                Command command = cmdService.getCommand(ExportToTextCommandHandler.COMMAND_ID);
                ParameterizedCommand cmd = ParameterizedCommand.generateCommand(command, parameters);
                IEvaluationContext context = handlerService.getCurrentState();
                List<TmfEventTableColumn> exportColumns = new ArrayList<>();
                for (int i : fTable.getColumnOrder()) {
                    TableColumn column = fTable.getColumns()[i];
                    // Omit the margin column and hidden columns
                    if (isVisibleEventColumn(column)) {
                        exportColumns.add(fColumns.get(i));
                    }
                }
                context.addVariable(ExportToTextCommandHandler.TMF_EVENT_TABLE_COLUMNS_ID, exportColumns);
                handlerService.executeCommandInContext(cmd, null, context);
            } catch (ExecutionException | NotDefinedException | NotEnabledException | NotHandledException e) {
                TraceUtils.displayErrorMsg(e);
            }
        }
    };
    final IAction addAsFilterAction = new Action(Messages.TmfEventsTable_AddAsFilterText) {

        @Override
        public void run() {
            applySearchAsFilter();
        }
    };
    final IAction clearFiltersAction = new Action(Messages.TmfEventsTable_ClearFiltersActionText) {

        @Override
        public void run() {
            clearFilters();
        }
    };
    final IAction collapseAction = new Action(Messages.TmfEventsTable_CollapseFilterMenuName) {

        @Override
        public void run() {
            applyFilter(new TmfCollapseFilter());
        }
    };
    final IAction synchronizeAction = new Action(Messages.TmfEventsTable_SynchronizeActionText, IAction.AS_CHECK_BOX) {

        @Override
        public void run() {
            TmfTraceManager.getInstance().updateTraceContext(NonNullUtils.checkNotNull(fTrace), builder -> builder.setSynchronized(isChecked()));
        }
    };
    class ToggleBookmarkAction extends Action {

        Long fRank;

        public ToggleBookmarkAction(final String text, final Long rank) {
            super(text);
            fRank = rank;
        }

        @Override
        public void run() {
            toggleBookmark(fRank);
        }
    }
    fHeaderPopupMenuManager = new MenuManager();
    fHeaderPopupMenuManager.setRemoveAllWhenShown(true);
    fHeaderPopupMenuManager.addMenuListener(manager -> {
        final Point point = fTable.toControl(fLastMenuCursorLocation);
        TableColumn selectedColumn = fTable.getColumn(point);
        if (selectedColumn != null && selectedColumn.getResizable()) {
            fHeaderPopupMenuManager.add(createAutoFitAction(selectedColumn));
            fHeaderPopupMenuManager.add(new Separator());
        }
        for (int index : fTable.getColumnOrder()) {
            TableColumn column = fTable.getColumns()[index];
            if (column.getData(Key.WIDTH) != null) {
                fHeaderPopupMenuManager.add(createShowColumnAction(column));
            }
        }
        fHeaderPopupMenuManager.add(new Separator());
        fHeaderPopupMenuManager.add(createShowAllAction());
        fHeaderPopupMenuManager.add(createResetAllAction());
    });
    fTablePopupMenuManager = new MenuManager();
    fTablePopupMenuManager.setRemoveAllWhenShown(true);
    fTablePopupMenuManager.addMenuListener(manager -> {
        if (fTable.getSelectionIndices().length == 1 && fTable.getSelectionIndices()[0] == 0) {
            // Right-click on header row
            if (fHeaderState == HeaderState.SEARCH) {
                fTablePopupMenuManager.add(addAsFilterAction);
            }
            return;
        }
        final Point point = fTable.toControl(fLastMenuCursorLocation);
        final TableItem item = fTable.getSelection().length > 0 ? fTable.getSelection()[0] : null;
        if (item != null) {
            final Rectangle imageBounds = item.getImageBounds(0);
            imageBounds.width = BOOKMARK_IMAGE.getBounds().width;
            if (point.x <= (imageBounds.x + imageBounds.width)) {
                // Right-click on left margin
                final Long rank = (Long) item.getData(Key.RANK);
                if ((rank != null) && (fBookmarksFile != null)) {
                    if (fBookmarksMap.containsKey(rank)) {
                        fTablePopupMenuManager.add(new ToggleBookmarkAction(Messages.TmfEventsTable_RemoveBookmarkActionText, rank));
                    } else {
                        fTablePopupMenuManager.add(new ToggleBookmarkAction(Messages.TmfEventsTable_AddBookmarkActionText, rank));
                    }
                }
                return;
            }
        }
        // Right-click on table
        if (fSelectedRank != -1 && fSelectedBeginRank != -1) {
            fTablePopupMenuManager.add(copyAction);
            fTablePopupMenuManager.add(new Separator());
        }
        if (fTable.isVisible() && fRawViewer.isVisible()) {
            fTablePopupMenuManager.add(hideTableAction);
            fTablePopupMenuManager.add(hideRawAction);
        } else if (!fTable.isVisible()) {
            fTablePopupMenuManager.add(showTableAction);
        } else if (!fRawViewer.isVisible()) {
            fTablePopupMenuManager.add(showRawAction);
        }
        fTablePopupMenuManager.add(exportToTextAction);
        fTablePopupMenuManager.add(new Separator());
        if (item != null) {
            final Object data = item.getData();
            Separator separator = null;
            if (data instanceof ITmfSourceLookup) {
                IContributionItem action = OpenSourceCodeAction.create(Messages.TmfSourceLookup_OpenSourceCodeActionText, (ITmfSourceLookup) data, fTable.getShell());
                if (action != null) {
                    fTablePopupMenuManager.add(action);
                    separator = new Separator();
                }
            }
            if (data instanceof ITmfModelLookup) {
                ITmfModelLookup event2 = (ITmfModelLookup) data;
                if (event2.getModelUri() != null) {
                    fTablePopupMenuManager.add(openModelAction);
                    separator = new Separator();
                }
                if (separator != null) {
                    fTablePopupMenuManager.add(separator);
                }
            }
        }
        /*
             * Only show collapse filter if at least one trace can be
             * collapsed.
             */
        boolean isCollapsible = false;
        if (fTrace != null) {
            for (ITmfTrace trace1 : TmfTraceManager.getTraceSet(fTrace)) {
                Class<? extends ITmfEvent> eventClass = trace1.getEventType();
                isCollapsible = ITmfCollapsibleEvent.class.isAssignableFrom(eventClass);
                if (isCollapsible) {
                    break;
                }
            }
        }
        if (isCollapsible && !fCollapseFilterEnabled) {
            fTablePopupMenuManager.add(collapseAction);
            fTablePopupMenuManager.add(new Separator());
        }
        fTablePopupMenuManager.add(clearFiltersAction);
        final ITmfFilterTreeNode[] savedFilters = FilterManager.getSavedFilters();
        if (savedFilters.length > 0) {
            final MenuManager subMenu = new MenuManager(Messages.TmfEventsTable_ApplyPresetFilterMenuName);
            for (final ITmfFilterTreeNode node : savedFilters) {
                if (node instanceof TmfFilterNode) {
                    final TmfFilterNode filter = (TmfFilterNode) node;
                    subMenu.add(new Action(filter.getFilterName()) {

                        @Override
                        public void run() {
                            applyFilter(filter);
                        }
                    });
                }
            }
            fTablePopupMenuManager.add(subMenu);
        }
        fTablePopupMenuManager.add(new Separator());
        ITmfTrace trace2 = fTrace;
        if (trace2 != null) {
            synchronizeAction.setChecked(TmfTraceManager.getInstance().getTraceContext(trace2).isSynchronized());
            fTablePopupMenuManager.add(synchronizeAction);
        }
        appendToTablePopupMenu(fTablePopupMenuManager, item);
    });
    fRawViewerPopupMenuManager = new MenuManager();
    fRawViewerPopupMenuManager.setRemoveAllWhenShown(true);
    fRawViewerPopupMenuManager.addMenuListener(manager -> {
        if (fTable.isVisible() && fRawViewer.isVisible()) {
            fRawViewerPopupMenuManager.add(hideTableAction);
            fRawViewerPopupMenuManager.add(hideRawAction);
        } else if (!fTable.isVisible()) {
            fRawViewerPopupMenuManager.add(showTableAction);
        } else if (!fRawViewer.isVisible()) {
            fRawViewerPopupMenuManager.add(showRawAction);
        }
        appendToRawPopupMenu(fRawViewerPopupMenuManager);
    });
    fHeaderMenu = fHeaderPopupMenuManager.createContextMenu(fTable);
    fTablePopup = fTablePopupMenuManager.createContextMenu(fTable);
    fTable.setMenu(fTablePopup);
    fRawTablePopup = fRawViewerPopupMenuManager.createContextMenu(fRawViewer);
    fRawViewer.setMenu(fRawTablePopup);
}

Example 3 with TmfCollapseFilter

use of org.eclipse.tracecompass.internal.tmf.core.filter.TmfCollapseFilter in project tracecompass by tracecompass.

the class TmfCollapseFilterTest method testMatches.

@Test
public void testMatches() {
    TmfCollapseFilter filter = new TmfCollapseFilter();
    assertTrue(filter.matches(fCollapsibleEvent1));
    assertFalse(filter.matches(fCollapsibleEvent2));
    assertFalse(filter.matches(fCollapsibleEvent1));
    assertFalse(filter.matches(fCollapsibleEvent2));
    assertTrue(filter.matches(fNonCollapsibleEvent1));
    assertTrue(filter.matches(fNonCollapsibleEvent1));
    assertTrue(filter.matches(fCollapsibleEvent1));
    assertFalse(filter.matches(fCollapsibleEvent2));
    assertTrue(filter.matches(fCollapsibleEvent3));
}

Example 4 with TmfCollapseFilter

use of org.eclipse.tracecompass.internal.tmf.core.filter.TmfCollapseFilter in project tracecompass by tracecompass.

the class TmfEventsTable method removeFilter.

/**
 * Remove a filter. Any other existing filters remain applied.
 *
 * @param filter
 *            The filter to remove
 * @since 2.0
 */
protected void removeFilter(ITmfFilter filter) {
    ITmfFilterTreeNode rootFilter = (ITmfFilterTreeNode) fTable.getData(Key.FILTER_OBJ);
    if (rootFilter == null) {
        return;
    }
    stopFilterThread();
    stopSearchThread();
    fFilterMatchCount = 0;
    fFilterCheckCount = 0;
    if (filter instanceof TmfCollapseFilter) {
        fCollapseFilterEnabled = false;
    } else if (filter instanceof ITmfFilterTreeNode) {
        rootFilter.removeChild((ITmfFilterTreeNode) filter);
    } else {
        for (ITmfFilterTreeNode child : rootFilter.getChildren()) {
            if (child instanceof TmfFilterObjectNode) {
                if (((TmfFilterObjectNode) child).getFilter().equals(filter)) {
                    rootFilter.removeChild(child);
                    break;
                }
            }
        }
    }
    if (!rootFilter.hasChildren() && !fCollapseFilterEnabled) {
        clearFilters();
        return;
    }
    fCache.applyFilter(rootFilter, fCollapseFilterEnabled);
    fHeaderBar.removeFilter(filter);
    fTable.clearAll();
    fTable.setData(Key.FILTER_OBJ, rootFilter);
    /* +1 for header row, +2 for top and bottom filter status rows */
    fTable.setItemCount(3);
    startFilterThread();
    fireFilterApplied(rootFilter);
    // Set original width
    fTable.getColumns()[MARGIN_COLUMN_INDEX].setWidth(0);
    packMarginColumn();
}

Example 5 with TmfCollapseFilter

use of org.eclipse.tracecompass.internal.tmf.core.filter.TmfCollapseFilter in project tracecompass by tracecompass.

the class TmfEventsCache method populateCache.

private synchronized void populateCache(final int index) {
    /* Check if the current job will fetch the requested event:
         * 1. The job must exist
         * 2. It must be running (i.e. not completed)
         * 3. The requested index must be within the cache range
         *
         * If the job meets these conditions, we simply exit.
         * Otherwise, we create a new job but we might have to cancel
         * an existing job for an obsolete range.
         */
    if (job != null) {
        if (job.getState() != Job.NONE) {
            if ((index >= fCacheStartIndex) && (index < (fCacheStartIndex + fCache.length))) {
                return;
            }
            // The new index is out of the requested range
            // Kill the job and start a new one
            job.cancel();
        }
    }
    // Populate the cache starting at the index that is one block less
    // of cache size than the requested index. The cache will hold two
    // consecutive blocks of cache size, centered on the requested index.
    fCacheStartIndex = Math.max(0, index - fCacheSize);
    fCacheEndIndex = fCacheStartIndex;
    job = new // $NON-NLS-1$
    Job(// $NON-NLS-1$
    "Fetching Events") {

        private int startIndex = fCacheStartIndex;

        private int skipCount = 0;

        @Override
        protected IStatus run(final IProgressMonitor monitor) {
            int nbRequested;
            if (fFilter == null) {
                nbRequested = fCache.length;
            } else {
                nbRequested = ITmfEventRequest.ALL_DATA;
                int i = startIndex / fCacheSize;
                if (i < fFilterIndex.size()) {
                    skipCount = startIndex - (i * fCacheSize);
                    startIndex = fFilterIndex.get(i);
                }
            }
            TmfEventRequest request = new TmfEventRequest(ITmfEvent.class, TmfTimeRange.ETERNITY, startIndex, nbRequested, TmfEventRequest.ExecutionType.FOREGROUND) {

                private int count = 0;

                private long rank = startIndex;

                private TmfCollapseFilter collapseFilter = fCollapseFilterEnabled ? new TmfCollapseFilter() : null;

                @Override
                public void handleData(ITmfEvent event) {
                    // If the job is canceled, cancel the request so waitForCompletion() will unlock
                    if (monitor.isCanceled()) {
                        cancel();
                        return;
                    }
                    super.handleData(event);
                    if ((fFilter == null) || fFilter.matches(event)) {
                        if (collapseFilter == null || collapseFilter.matches(event)) {
                            if (skipCount-- <= 0) {
                                synchronized (TmfEventsCache.this) {
                                    if (monitor.isCanceled()) {
                                        return;
                                    }
                                    fCache[count] = new CachedEvent(event, rank);
                                    count++;
                                    fCacheEndIndex++;
                                }
                                if (fFilter != null) {
                                    fTable.cacheUpdated(false);
                                }
                            }
                        } else if ((count > 0) && (skipCount <= 0)) {
                            fCache[count - 1].repeatCount++;
                        }
                    }
                    if (count >= fCache.length) {
                        cancel();
                    } else if ((fFilter != null) && (count >= (fTable.getTable().getItemCount() - 3))) {
                        // -1 for header row, -2 for top and bottom filter status rows
                        cancel();
                    }
                    rank++;
                }
            };
            ((ITmfEventProvider) fTrace).sendRequest(request);
            try {
                request.waitForCompletion();
            } catch (InterruptedException e) {
                // $NON-NLS-1$
                Activator.getDefault().logError("Wait for completion interrupted for populateCache ", e);
                Thread.currentThread().interrupt();
            }
            fTable.cacheUpdated(true);
            // Flag the UI thread that the cache is ready
            if (monitor.isCanceled()) {
                return Status.CANCEL_STATUS;
            }
            return Status.OK_STATUS;
        }
    };
    // job.setSystem(true);
    job.setPriority(Job.SHORT);
    job.schedule();
}