* http://www.eclipse.org/legal/epl-v10.html
*
* Contributors:
- * Francois Chouinard - Initial API and implementation
- * Patrick Tasse - Factored out from events view
- * Francois Chouinard - Replaced Table by TmfVirtualTable
- * Patrick Tasse - Filter implementation (inspired by www.eclipse.org/mat)
+ * Francois Chouinard - Initial API and implementation, replaced Table by TmfVirtualTable
+ * Patrick Tasse - Factored out from events view,
+ * Filter implementation (inspired by www.eclipse.org/mat)
* Ansgar Radermacher - Support navigation to model URIs (Bug 396956)
* Bernd Hufmann - Updated call site and model URI implementation
+ * Alexandre Montplaisir - Update to new column API
*******************************************************************************/
package org.eclipse.linuxtools.tmf.ui.viewers.events;
import java.io.FileNotFoundException;
import java.util.ArrayList;
-import java.util.Arrays;
import java.util.Collection;
import java.util.HashMap;
+import java.util.LinkedList;
import java.util.List;
import java.util.Map.Entry;
import java.util.regex.Pattern;
import org.eclipse.jface.viewers.SelectionChangedEvent;
import org.eclipse.jface.viewers.StructuredSelection;
import org.eclipse.jface.window.Window;
+import org.eclipse.linuxtools.internal.tmf.core.filter.TmfCollapseFilter;
import org.eclipse.linuxtools.internal.tmf.ui.Activator;
import org.eclipse.linuxtools.internal.tmf.ui.Messages;
import org.eclipse.linuxtools.internal.tmf.ui.commands.ExportToTextCommandHandler;
import org.eclipse.linuxtools.tmf.core.component.ITmfEventProvider;
import org.eclipse.linuxtools.tmf.core.component.TmfComponent;
import org.eclipse.linuxtools.tmf.core.event.ITmfEvent;
+import org.eclipse.linuxtools.tmf.core.event.collapse.ITmfCollapsibleEvent;
import org.eclipse.linuxtools.tmf.core.event.lookup.ITmfCallsite;
import org.eclipse.linuxtools.tmf.core.event.lookup.ITmfModelLookup;
import org.eclipse.linuxtools.tmf.core.event.lookup.ITmfSourceLookup;
import org.eclipse.linuxtools.tmf.core.request.TmfEventRequest;
import org.eclipse.linuxtools.tmf.core.signal.TmfEventFilterAppliedSignal;
import org.eclipse.linuxtools.tmf.core.signal.TmfEventSearchAppliedSignal;
+import org.eclipse.linuxtools.tmf.core.signal.TmfEventSelectedSignal;
import org.eclipse.linuxtools.tmf.core.signal.TmfSignalHandler;
import org.eclipse.linuxtools.tmf.core.signal.TmfTimeSynchSignal;
import org.eclipse.linuxtools.tmf.core.signal.TmfTraceUpdatedSignal;
import org.eclipse.linuxtools.tmf.core.timestamp.TmfTimestamp;
import org.eclipse.linuxtools.tmf.core.trace.ITmfContext;
import org.eclipse.linuxtools.tmf.core.trace.ITmfTrace;
+import org.eclipse.linuxtools.tmf.core.trace.TmfTraceManager;
import org.eclipse.linuxtools.tmf.core.trace.location.ITmfLocation;
import org.eclipse.linuxtools.tmf.ui.viewers.events.TmfEventsCache.CachedEvent;
+import org.eclipse.linuxtools.tmf.ui.viewers.events.columns.TmfEventTableColumn;
+import org.eclipse.linuxtools.tmf.ui.viewers.events.columns.TmfEventTableFieldColumn;
import org.eclipse.linuxtools.tmf.ui.views.colors.ColorSetting;
import org.eclipse.linuxtools.tmf.ui.views.colors.ColorSettingsManager;
import org.eclipse.linuxtools.tmf.ui.views.colors.IColorSettingsListener;
import org.eclipse.linuxtools.tmf.ui.views.filter.FilterManager;
import org.eclipse.linuxtools.tmf.ui.widgets.rawviewer.TmfRawEventViewer;
-import org.eclipse.linuxtools.tmf.ui.widgets.virtualtable.ColumnData;
import org.eclipse.linuxtools.tmf.ui.widgets.virtualtable.TmfVirtualTable;
import org.eclipse.swt.SWT;
import org.eclipse.swt.custom.SashForm;
import com.google.common.base.Joiner;
import com.google.common.collect.HashMultimap;
+import com.google.common.collect.ImmutableList;
import com.google.common.collect.Multimap;
/**
*
* This is a view that will list events that are read from a trace.
*
- * @version 1.0
* @author Francois Chouinard
* @author Patrick Tasse
* @since 2.0
*/
protected static final @NonNull String[] EMPTY_STRING_ARRAY = new String[0];
+ /**
+ * Empty string
+ * @since 3.1
+ */
+ protected static final @NonNull String EMPTY_STRING = ""; //$NON-NLS-1$
+
+ private static final boolean IS_LINUX = System.getProperty("os.name").contains("Linux") ? true : false; //$NON-NLS-1$ //$NON-NLS-2$
+
private static final Image BOOKMARK_IMAGE = Activator.getDefault().getImageFromPath(
"icons/elcl16/bookmark_obj.gif"); //$NON-NLS-1$
private static final Image SEARCH_IMAGE = Activator.getDefault().getImageFromPath("icons/elcl16/search.gif"); //$NON-NLS-1$
private static final String FILTER_HINT = Messages.TmfEventsTable_FilterHint;
private static final int MAX_CACHE_SIZE = 1000;
+ private static final int MARGIN_COLUMN_INDEX = 0;
+ private static final int FILTER_SUMMARY_INDEX = 1;
+ private static final int EVENT_COLUMNS_START_INDEX = MARGIN_COLUMN_INDEX + 1;
+
+ /**
+ * Default set of columns to use for trace types that do not specify
+ * anything
+ * @since 3.2
+ */
+ public static final Collection<TmfEventTableColumn> DEFAULT_COLUMNS = ImmutableList.of(
+ TmfEventTableColumn.BaseColumns.TIMESTAMP,
+ TmfEventTableColumn.BaseColumns.SOURCE,
+ TmfEventTableColumn.BaseColumns.EVENT_TYPE,
+ TmfEventTableColumn.BaseColumns.REFERENCE,
+ TmfEventTableColumn.BaseColumns.CONTENTS
+ );
+
/**
* The events table search/filter keys
*
private SashForm fSashForm;
private TmfRawEventViewer fRawViewer;
private ITmfTrace fTrace;
- private boolean fPackDone = false;
+ volatile private boolean fPackDone = false;
private HeaderState fHeaderState = HeaderState.SEARCH;
private long fSelectedRank = 0;
private ITmfTimestamp fSelectedBeginTimestamp = null;
private Color fGreenColor;
private Font fBoldFont;
- // Table column names
- private static final String[] COLUMN_NAMES = new String[] { Messages.TmfEventsTable_TimestampColumnHeader,
- Messages.TmfEventsTable_SourceColumnHeader, Messages.TmfEventsTable_TypeColumnHeader,
- Messages.TmfEventsTable_ReferenceColumnHeader, Messages.TmfEventsTable_ContentColumnHeader };
-
- private static final ColumnData[] COLUMN_DATA = new ColumnData[] { new ColumnData(COLUMN_NAMES[0], 100, SWT.LEFT),
- new ColumnData(COLUMN_NAMES[1], 100, SWT.LEFT), new ColumnData(COLUMN_NAMES[2], 100, SWT.LEFT),
- new ColumnData(COLUMN_NAMES[3], 100, SWT.LEFT), new ColumnData(COLUMN_NAMES[4], 100, SWT.LEFT) };
+ private final List<TmfEventTableColumn> fColumns = new LinkedList<>();
// Event cache
private final TmfEventsCache fCache;
// ------------------------------------------------------------------------
/**
- * Basic constructor, will use default column data.
+ * Basic constructor, using the default set of columns
*
* @param parent
* The parent composite UI object
* The size of the event table cache
*/
public TmfEventsTable(final Composite parent, final int cacheSize) {
- this(parent, cacheSize, COLUMN_DATA);
+ this(parent, cacheSize, DEFAULT_COLUMNS);
}
/**
- * Advanced constructor, where we also define which column data to use.
+ * Legacy constructor, using ColumnData to define columns
*
* @param parent
* The parent composite UI object
* @param cacheSize
* The size of the event table cache
* @param columnData
- * The column data to use for this table
+ * Unused
+ * @deprecated Deprecated constructor, use
+ * {@link #TmfEventsTable(Composite, int, Collection)}
+ */
+ @Deprecated
+ public TmfEventsTable(final Composite parent, int cacheSize,
+ final org.eclipse.linuxtools.tmf.ui.widgets.virtualtable.ColumnData[] columnData) {
+ /*
+ * We'll do a "best-effort" to keep trace types still using this API to
+ * keep working, by defining a TmfEventTableFieldColumn for each
+ * ColumnData they passed.
+ */
+ this(parent, cacheSize, convertFromColumnData(columnData));
+ }
+
+ @Deprecated
+ private static Collection<TmfEventTableColumn> convertFromColumnData(
+ org.eclipse.linuxtools.tmf.ui.widgets.virtualtable.ColumnData[] columnData) {
+
+ ImmutableList.Builder<TmfEventTableColumn> builder = new ImmutableList.Builder<>();
+ for (org.eclipse.linuxtools.tmf.ui.widgets.virtualtable.ColumnData col : columnData) {
+ String header = col.header;
+ if (header != null) {
+ builder.add(new TmfEventTableFieldColumn(header));
+ }
+ }
+ return builder.build();
+ }
+
+ /**
+ * Standard constructor, where we define which columns to use.
+ *
+ * @param parent
+ * The parent composite UI object
+ * @param cacheSize
+ * The size of the event table cache
+ * @param columns
+ * The columns to use in this table.
+ * <p>
+ * The iteration order of this collection will correspond to the
+ * initial ordering of this series of columns in the table.
+ * </p>
+ * @since 3.1
*/
- public TmfEventsTable(final Composite parent, int cacheSize, final ColumnData[] columnData) {
+ public TmfEventsTable(final Composite parent, int cacheSize,
+ Collection<? extends TmfEventTableColumn> columns) {
super("TmfEventsTable"); //$NON-NLS-1$
fComposite = new Composite(parent, SWT.NONE);
fTable.setHeaderVisible(true);
fTable.setLinesVisible(true);
- // Set the columns
- setColumnHeaders(columnData);
+ // Setup the columns
+ if (columns != null) {
+ fColumns.addAll(columns);
+ }
+
+ TmfMarginColumn collapseCol = new TmfMarginColumn();
+ fColumns.add(MARGIN_COLUMN_INDEX, collapseCol);
- // Set the default column field ids if this is not a subclass
- if (Arrays.equals(columnData, COLUMN_DATA)) {
- fTable.getColumns()[0].setData(Key.FIELD_ID, ITmfEvent.EVENT_FIELD_TIMESTAMP);
- fTable.getColumns()[1].setData(Key.FIELD_ID, ITmfEvent.EVENT_FIELD_SOURCE);
- fTable.getColumns()[2].setData(Key.FIELD_ID, ITmfEvent.EVENT_FIELD_TYPE);
- fTable.getColumns()[3].setData(Key.FIELD_ID, ITmfEvent.EVENT_FIELD_REFERENCE);
- fTable.getColumns()[4].setData(Key.FIELD_ID, ITmfEvent.EVENT_FIELD_CONTENT);
+ // Create the UI columns in the table
+ for (TmfEventTableColumn col : fColumns) {
+ TableColumn column = fTable.newTableColumn(SWT.LEFT);
+ column.setText(col.getHeaderName());
+ column.setToolTipText(col.getHeaderTooltip());
+ column.setData(Key.FIELD_ID, col.getFilterFieldId());
+ column.pack();
+ if (col instanceof TmfMarginColumn) {
+ column.setResizable(false);
+ }
}
// Set the frozen row for header row
}
}
}
- if (e.item.getData() != null) {
+ if (e.item.getData() instanceof ITmfEvent) {
+ broadcast(new TmfEventSelectedSignal(TmfEventsTable.this, (ITmfEvent) e.item.getData()));
fireSelectionChanged(new SelectionChangedEvent(TmfEventsTable.this, new StructuredSelection(e.item.getData())));
} else {
fireSelectionChanged(new SelectionChangedEvent(TmfEventsTable.this, StructuredSelection.EMPTY));
final CachedEvent cachedEvent = fCache.getEvent(index);
if (cachedEvent != null) {
- setItemData(item, cachedEvent.event, cachedEvent.rank);
+ setItemData(item, cachedEvent, cachedEvent.rank);
return;
}
layout.marginWidth = 2;
tooltipShell.setLayout(layout);
final Label label = new Label(tooltipShell, SWT.WRAP);
- String text = rank.toString() + (tooltipText != null ? ": " + tooltipText : ""); //$NON-NLS-1$ //$NON-NLS-2$
+ String text = rank.toString() + (tooltipText != null ? ": " + tooltipText : EMPTY_STRING); //$NON-NLS-1$
label.setForeground(PlatformUI.getWorkbench().getDisplay().getSystemColor(SWT.COLOR_INFO_FOREGROUND));
label.setBackground(PlatformUI.getWorkbench().getDisplay().getSystemColor(SWT.COLOR_INFO_BACKGROUND));
label.setText(text);
* the method toDisplay() expects coordinates relative to an origin that includes the table header.
*/
int y = event.y;
- if (System.getProperty("os.name").contains("Linux")) { //$NON-NLS-1$ //$NON-NLS-2$
+ if (IS_LINUX) {
y += fTable.getHeaderHeight();
}
Point pt = fTable.toDisplay(event.x, y);
createPopupMenu();
}
+ // ------------------------------------------------------------------------
+ // Operations
+ // ------------------------------------------------------------------------
+
/**
* Create a pop-up menu.
*/
IMarker marker = null;
try {
String fileName = cs.getFileName();
- final String trimmedPath = fileName.replaceAll("\\.\\./", ""); //$NON-NLS-1$ //$NON-NLS-2$
+ final String trimmedPath = fileName.replaceAll("\\.\\./", EMPTY_STRING); //$NON-NLS-1$
final ArrayList<IFile> files = new ArrayList<>();
ResourcesPlugin.getWorkspace().getRoot().accept(new IResourceVisitor() {
@Override
ICommandService cmdService = (ICommandService) activePage.getActiveEditor().getSite().getService(ICommandService.class);
try {
HashMap<String, Object> parameters = new HashMap<>();
- StringBuilder header = new StringBuilder();
- boolean needTab = false;
- for (TableColumn tc: fTable.getColumns()) {
- if (needTab) {
- header.append('\t');
- }
- header.append(tc.getText());
- needTab = true;
- }
Command command = cmdService.getCommand(ExportToTextCommandHandler.COMMAND_ID);
- ParameterizedCommand cmd = ParameterizedCommand.generateCommand(command,parameters);
+ ParameterizedCommand cmd = ParameterizedCommand.generateCommand(command, parameters);
+
IEvaluationContext context = handlerService.getCurrentState();
- context.addVariable(ExportToTextCommandHandler.TMF_EVENT_TABLE_HEADER_ID, header.toString());
- context.addVariable(ExportToTextCommandHandler.TMF_EVENT_TABLE_PARAMETER_ID, TmfEventsTable.this);
+ // Omit the margin column
+ List<TmfEventTableColumn> exportColumns = fColumns.subList(EVENT_COLUMNS_START_INDEX, fColumns.size());
+ context.addVariable(ExportToTextCommandHandler.TMF_EVENT_TABLE_COLUMNS_ID, exportColumns);
+
handlerService.executeCommandInContext(cmd, null, context);
} catch (ExecutionException e) {
displayException(e);
}
};
+ final IAction collapseAction = new Action(Messages.TmfEventsTable_CollapseFilterMenuName) {
+ @Override
+ public void run() {
+ applyFilter(new TmfCollapseFilter());
+ }
+ };
+
class ToggleBookmarkAction extends Action {
Long fRank;
}
}
+ // only show collapse filter if at least one trace can be collapsed
+ boolean isCollapsible = false;
+ if (fTrace != null) {
+ ITmfTrace traces[] = TmfTraceManager.getTraceSet(fTrace);
+ for (ITmfTrace trace : traces) {
+ Class <? extends ITmfEvent> eventClass = trace.getEventType();
+ isCollapsible = ITmfCollapsibleEvent.class.isAssignableFrom(eventClass);
+ if (isCollapsible) {
+ break;
+ }
+ }
+ }
+
+ if (isCollapsible && !(fTable.getData(Key.FILTER_OBJ) instanceof TmfCollapseFilter)) {
+ tablePopupMenu.add(collapseAction);
+ tablePopupMenu.add(new Separator());
+ }
+
tablePopupMenu.add(clearFiltersAction);
final ITmfFilterTreeNode[] savedFilters = FilterManager.getSavedFilters();
if (savedFilters.length > 0) {
/**
* @param columnData
- *
- * FIXME: Add support for column selection
+ * columnData
+ * @deprecated The column headers are now set at the constructor, this
+ * shouldn't be called anymore.
*/
- protected void setColumnHeaders(final ColumnData[] columnData) {
- fTable.setColumnHeaders(columnData);
+ @Deprecated
+ protected void setColumnHeaders(final org.eclipse.linuxtools.tmf.ui.widgets.virtualtable.ColumnData [] columnData) {
+ /* No-op */
}
/**
* Which rank this event has in the trace/experiment
*/
protected void setItemData(final TableItem item, final ITmfEvent event, final long rank) {
- item.setText(getItemStrings(event));
+ String[] itemStrings = getItemStrings(fColumns, event);
+ item.setText(itemStrings);
item.setData(event);
item.setData(Key.TIMESTAMP, new TmfTimestamp(event.getTimestamp()));
item.setData(Key.RANK, rank);
} else {
item.setImage((Image) null);
}
+
+ if ((itemStrings[MARGIN_COLUMN_INDEX] != null) && !itemStrings[MARGIN_COLUMN_INDEX].isEmpty()) {
+ packMarginColumn();
+ }
}
/**
txtKey = Key.FILTER_TXT;
}
item.setForeground(fGrayColor);
- for (int i = 0; i < fTable.getColumns().length; i++) {
+ // Ignore collapse and image column
+ for (int i = EVENT_COLUMNS_START_INDEX; i < fTable.getColumns().length; i++) {
final TableColumn column = fTable.getColumns()[i];
final String filter = (String) column.getData(txtKey);
if (filter == null) {
*/
protected void setFilterStatusRowItemData(final TableItem item) {
for (int i = 0; i < fTable.getColumns().length; i++) {
- if (i == 0) {
+ if (i == MARGIN_COLUMN_INDEX) {
if ((fTrace == null) || (fFilterCheckCount == fTrace.getNbEvents())) {
item.setImage(FILTER_IMAGE);
} else {
item.setImage(STOP_IMAGE);
}
- item.setText(0, fFilterMatchCount + "/" + fFilterCheckCount); //$NON-NLS-1$
+ }
+
+ if (i == FILTER_SUMMARY_INDEX) {
+ item.setText(FILTER_SUMMARY_INDEX, fFilterMatchCount + "/" + fFilterCheckCount); //$NON-NLS-1$
} else {
- item.setText(i, ""); //$NON-NLS-1$
+ item.setText(i, EMPTY_STRING);
}
}
item.setData(null);
}
fireFilterApplied(null);
updateStatusLine(null);
+
+ // Set original width
+ fTable.getColumns()[MARGIN_COLUMN_INDEX].setWidth(0);
+ packMarginColumn();
}
/**
if (request.isCancelled()) {
return;
}
+ boolean refresh = false;
if (filter.matches(event)) {
final long rank = fFilterCheckCount;
final int index = (int) fFilterMatchCount;
fFilterMatchCount++;
fCache.storeEvent(event, rank, index);
- refreshTable();
- } else if ((fFilterCheckCount % 100) == 0) {
+ refresh = true;
+ } else {
+ if (filter instanceof TmfCollapseFilter) {
+ fCache.updateCollapsedEvent((int) fFilterMatchCount - 1);
+ }
+ }
+
+ if (refresh || (fFilterCheckCount % 100) == 0) {
refreshTable();
}
fFilterCheckCount++;
return;
}
fTable.setRedraw(false);
+ try {
+ TableColumn tableColumns[] = fTable.getColumns();
+ for (int i = 0; i < tableColumns.length; i++) {
+ final TableColumn column = tableColumns[i];
+ packSingleColumn(i, column);
+ }
+ } finally {
+ // Make sure that redraw is always enabled.
+ fTable.setRedraw(true);
+ }
+ fPackDone = true;
+ }
- boolean isLinux = System.getProperty("os.name").contains("Linux") ? true : false; //$NON-NLS-1$ //$NON-NLS-2$
- TableColumn tableColumns[] = fTable.getColumns();
- for (int i = 0; i < tableColumns.length; i++) {
- final TableColumn column = tableColumns[i];
- final int headerWidth = column.getWidth();
- column.pack();
- // Workaround for Linux which doesn't consider the image width of
- // search/filter row in TableColumn.pack() after having executed
- // TableItem.setImage((Image)null) for other rows than search/filter row.
- if (isLinux && (i == 0)) {
- column.setWidth(column.getWidth() + SEARCH_IMAGE.getBounds().width);
- }
+ private void packMarginColumn() {
+ TableColumn[] columns = fTable.getColumns();
+ if (columns.length > 0) {
+ packSingleColumn(0, columns[0]);
+ }
+ }
- if (column.getWidth() < headerWidth) {
- column.setWidth(headerWidth);
- }
+ private void packSingleColumn(int i, final TableColumn column) {
+ final int headerWidth = column.getWidth();
+ column.pack();
+ // Workaround for Linux which doesn't consider the image width of
+ // search/filter row in TableColumn.pack() after having executed
+ // TableItem.setImage((Image)null) for other rows than search/filter row.
+ boolean isCollapseFilter = fTable.getData(Key.FILTER_OBJ) instanceof TmfCollapseFilter;
+ if (IS_LINUX && (i == 0) && isCollapseFilter) {
+ column.setWidth(column.getWidth() + SEARCH_IMAGE.getBounds().width);
}
- fTable.setRedraw(true);
- fPackDone = true;
+ if (column.getWidth() < headerWidth) {
+ column.setWidth(headerWidth);
+ }
}
/**
- * Get the contents of the row in the events table corresponding to an
- * event. The order of the elements corresponds to the order of the columns.
+ * Get the array of item strings (e.g., what to display in each cell of the
+ * table row) corresponding to the columns and trace event passed in
+ * parameter. The order of the Strings in the returned array will correspond
+ * to the iteration order of 'columns'.
*
- * TODO Use column IDs, not indexes, so that the column order can be
- * re-arranged.
+ * <p>
+ * To ensure consistent results, make sure only call this within a scope
+ * synchronized on 'columns'! If the order of 'columns' changes right after
+ * this method is called, the returned value won't be ordered correctly
+ * anymore.
+ */
+ private static String[] getItemStrings(List<TmfEventTableColumn> columns, ITmfEvent event) {
+ if (event == null) {
+ return EMPTY_STRING_ARRAY;
+ }
+ synchronized (columns) {
+ List<String> itemStrings = new ArrayList<>(columns.size());
+ for (TmfEventTableColumn column : columns) {
+ ITmfEvent passedEvent = event;
+ if (!(column instanceof TmfMarginColumn) && (event instanceof CachedEvent)) {
+ // Make sure that the event object from the trace is passed
+ // to all columns but the TmfMarginColumn
+ passedEvent = ((CachedEvent) event).event;
+ }
+ if (passedEvent == null) {
+ itemStrings.add(EMPTY_STRING);
+ } else {
+ itemStrings.add(column.getItemString(passedEvent));
+ }
+
+ }
+ return itemStrings.toArray(new String[0]);
+ }
+ }
+
+ /**
+ * Get the contents of the row in the events table corresponding to an
+ * event. The order of the elements corresponds to the current order of the
+ * columns.
*
* @param event
* The event printed in this row
* @since 3.0
*/
public String[] getItemStrings(ITmfEvent event) {
- if (event == null) {
- return EMPTY_STRING_ARRAY;
- }
- return new String[] {
- event.getTimestamp().toString(),
- event.getSource(),
- event.getType().getName(),
- event.getReference(),
- event.getContent().toString()
- };
+ return getItemStrings(fColumns, event);
}
/**
*/
public void setStatusLineManager(IStatusLineManager statusLineManager) {
if (fStatusLineManager != null && statusLineManager == null) {
- fStatusLineManager.setMessage(""); //$NON-NLS-1$
+ fStatusLineManager.setMessage(EMPTY_STRING);
}
fStatusLineManager = statusLineManager;
}
fTable.refresh();
fTable.redraw();
}
+
+ /**
+ * Margin column for images and special text (e.g. collapse count)
+ */
+ private static final class TmfMarginColumn extends TmfEventTableColumn {
+
+ private static final @NonNull String HEADER = EMPTY_STRING;
+
+ /**
+ * Constructor
+ */
+ public TmfMarginColumn() {
+ super(HEADER);
+ }
+
+ @Override
+ public String getItemString(ITmfEvent event) {
+ if (!(event instanceof CachedEvent) || ((CachedEvent) event).repeatCount == 0) {
+ return EMPTY_STRING;
+ }
+ return "+" + ((CachedEvent) event).repeatCount; //$NON-NLS-1$
+ }
+
+ @Override
+ public String getFilterFieldId() {
+ return null;
+ }
+ }
+
}
projects / deliverable / tracecompass.git / blobdiff