package org.eclipse.tracecompass.analysis.timing.ui.views.segmentstore.table;
+import java.text.DecimalFormat;
+import java.text.Format;
+
import org.eclipse.jdt.annotation.Nullable;
import org.eclipse.jface.action.Action;
import org.eclipse.jface.action.IAction;
import org.eclipse.swt.widgets.Display;
import org.eclipse.swt.widgets.Event;
import org.eclipse.swt.widgets.Listener;
+import org.eclipse.swt.widgets.Table;
import org.eclipse.swt.widgets.TableColumn;
-import org.eclipse.tracecompass.analysis.timing.core.segmentstore.AbstractSegmentStoreAnalysisModule;
import org.eclipse.tracecompass.analysis.timing.core.segmentstore.IAnalysisProgressListener;
+import org.eclipse.tracecompass.analysis.timing.core.segmentstore.ISegmentStoreProvider;
import org.eclipse.tracecompass.common.core.NonNullUtils;
import org.eclipse.tracecompass.internal.analysis.timing.ui.views.segmentstore.table.Messages;
import org.eclipse.tracecompass.internal.analysis.timing.ui.views.segmentstore.table.SegmentStoreContentProvider;
import org.eclipse.tracecompass.segmentstore.core.ISegment;
import org.eclipse.tracecompass.segmentstore.core.ISegmentStore;
import org.eclipse.tracecompass.segmentstore.core.SegmentComparators;
+import org.eclipse.tracecompass.tmf.core.analysis.IAnalysisModule;
import org.eclipse.tracecompass.tmf.core.segment.ISegmentAspect;
import org.eclipse.tracecompass.tmf.core.signal.TmfSelectionRangeUpdatedSignal;
import org.eclipse.tracecompass.tmf.core.signal.TmfSignalHandler;
import org.eclipse.tracecompass.tmf.core.signal.TmfTraceOpenedSignal;
import org.eclipse.tracecompass.tmf.core.signal.TmfTraceSelectedSignal;
import org.eclipse.tracecompass.tmf.core.timestamp.ITmfTimestamp;
-import org.eclipse.tracecompass.tmf.core.timestamp.TmfNanoTimestamp;
+import org.eclipse.tracecompass.tmf.core.timestamp.TmfTimestamp;
import org.eclipse.tracecompass.tmf.core.timestamp.TmfTimestampFormat;
import org.eclipse.tracecompass.tmf.core.trace.ITmfTrace;
import org.eclipse.tracecompass.tmf.core.trace.TmfTraceManager;
import org.eclipse.tracecompass.tmf.ui.viewers.table.TmfSimpleTableViewer;
+import com.google.common.annotations.VisibleForTesting;
+
/**
- * Displays the segment store analysis data in a column table
+ * Displays the segment store provider data in a column table
*
* @author France Lapointe Nguyen
* @since 2.0
*/
public abstract class AbstractSegmentStoreTableViewer extends TmfSimpleTableViewer {
+ private static final Format FORMATTER = new DecimalFormat("###,###.##"); //$NON-NLS-1$
+
// ------------------------------------------------------------------------
// Attributes
// ------------------------------------------------------------------------
/**
* Abstract class for the column label provider for the segment store
- * analysis table viewer
+ * provider table viewer
*/
private abstract class SegmentStoreTableColumnLabelProvider extends ColumnLabelProvider {
}
/**
- * Listener to update the model with the segment store analysis results
- * once the analysis is fully completed
+ * Listener to update the model with the segment store provider results once
+ * its store is fully completed
*/
- private final class AnalysisProgressListener implements IAnalysisProgressListener {
+ private final class SegmentStoreProviderProgressListener implements IAnalysisProgressListener {
@Override
- public void onComplete(AbstractSegmentStoreAnalysisModule activeAnalysis, ISegmentStore<ISegment> data) {
- // Check if the active trace was changed while the analysis was
- // running
- if (activeAnalysis.equals(fAnalysisModule)) {
+ public void onComplete(ISegmentStoreProvider activeProvider, ISegmentStore<ISegment> data) {
+ // Check if the active trace was changed while the provider was
+ // building its segment store
+ if (activeProvider.equals(fSegmentProvider)) {
updateModel(data);
}
}
@Override
public void widgetSelected(@Nullable SelectionEvent e) {
ISegment selectedSegment = ((ISegment) NonNullUtils.checkNotNull(e).item.getData());
- ITmfTimestamp start = new TmfNanoTimestamp(selectedSegment.getStart());
- ITmfTimestamp end = new TmfNanoTimestamp(selectedSegment.getEnd());
+ ITmfTimestamp start = TmfTimestamp.fromNanos(selectedSegment.getStart());
+ ITmfTimestamp end = TmfTimestamp.fromNanos(selectedSegment.getEnd());
TmfSignalManager.dispatchSignal(new TmfSelectionRangeUpdatedSignal(AbstractSegmentStoreTableViewer.this, start, end));
}
}
/**
- * Current segment store analysis module
+ * Current segment store provider
*/
- private @Nullable AbstractSegmentStoreAnalysisModule fAnalysisModule = null;
+ private @Nullable ISegmentStoreProvider fSegmentProvider = null;
/**
- * Analysis progress listener
+ * provider progress listener
*/
- private AnalysisProgressListener fListener;
+ private SegmentStoreProviderProgressListener fListener;
/**
* Flag to create columns once
super(tableViewer);
// Sort order of the content provider is by start time by default
getTableViewer().setContentProvider(new SegmentStoreContentProvider());
- ITmfTrace trace = TmfTraceManager.getInstance().getActiveTrace();
- if (trace != null) {
- fAnalysisModule = getSegmentStoreAnalysisModule(trace);
- }
createColumns();
getTableViewer().getTable().addSelectionListener(new TableSelectionListener());
addPackListener();
- fListener = new AnalysisProgressListener();
+ fListener = new SegmentStoreProviderProgressListener();
}
// ------------------------------------------------------------------------
// Operations
// ------------------------------------------------------------------------
+ /**
+ * Sets the segment provider, use only in test, only run in display thread
+ *
+ * @param segmentProvider
+ * the segment provider
+ * @since 1.2
+ */
+ @VisibleForTesting
+ public void setSegmentProvider(ISegmentStoreProvider segmentProvider) {
+ fSegmentProvider = segmentProvider;
+ // Sort order of the content provider is by start time by default
+ getTableViewer().setContentProvider(new SegmentStoreContentProvider());
+
+ Table table = getTableViewer().getTable();
+ table.setRedraw(false);
+ while (table.getColumnCount() > 0) {
+ table.getColumn(0).dispose();
+ }
+ createColumns();
+ createProviderColumns();
+ getTableViewer().getTable().addSelectionListener(new TableSelectionListener());
+ addPackListener();
+ fListener = new SegmentStoreProviderProgressListener();
+ table.setRedraw(true);
+ }
+
/**
* Create default columns for start time, end time and duration
*/
createColumn(Messages.SegmentStoreTableViewer_duration, new SegmentStoreTableColumnLabelProvider() {
@Override
public String getTextForSegment(ISegment input) {
- return NonNullUtils.nullToEmptyString(Long.toString(input.getLength()));
+ return NonNullUtils.nullToEmptyString(FORMATTER.format(input.getLength()));
}
}, SegmentComparators.INTERVAL_LENGTH_COMPARATOR);
}
/**
- * Create columns specific to the analysis
+ * Create columns specific to the provider
*/
- protected void createAnalysisColumns() {
+ protected void createProviderColumns() {
if (!fColumnsCreated) {
- AbstractSegmentStoreAnalysisModule analysis = getAnalysisModule();
- if (analysis != null) {
- for (final ISegmentAspect aspect : analysis.getSegmentAspects()) {
+ ISegmentStoreProvider provider = getSegmentProvider();
+ if (provider != null) {
+ for (final ISegmentAspect aspect : provider.getSegmentAspects()) {
createColumn(aspect.getName(), new SegmentStoreTableColumnLabelProvider() {
@Override
public String getTextForSegment(ISegment input) {
return NonNullUtils.nullToEmptyString(aspect.resolve(input));
}
},
- aspect.getComparator());
+ aspect.getComparator());
}
}
fColumnsCreated = true;
}
/**
- * Set the data into the viewer. Will update model is analysis is completed
- * or run analysis if not completed
+ * Set the data into the viewer. It will update the model. If the provider
+ * is an analysis, the analysis will be scheduled.
*
- * @param analysis
- * segment store analysis module
+ * @param provider
+ * segment store provider
*/
- public void setData(@Nullable AbstractSegmentStoreAnalysisModule analysis) {
- // Set the current segment store analysis module
- fAnalysisModule = analysis;
- if (analysis == null) {
+ public void setData(@Nullable ISegmentStoreProvider provider) {
+ // Set the current segment store provider
+ fSegmentProvider = provider;
+ if (provider == null) {
updateModel(null);
return;
}
- createAnalysisColumns();
+ createProviderColumns();
- ISegmentStore<ISegment> results = analysis.getResults();
- // If results are not null, then analysis is completed and model can be
- // updated
- if (results != null) {
- updateModel(results);
+ ISegmentStore<ISegment> segStore = provider.getSegmentStore();
+ // If results are not null, then the segment of the provider is ready
+ // and model can be updated
+ if (segStore != null) {
+ updateModel(segStore);
return;
}
- // If results are null, then add completion listener and run analysis
+ // If results are null, then add completion listener and if the provider
+ // is an analysis, run the analysis
updateModel(null);
- analysis.addListener(fListener);
- analysis.schedule();
+ provider.addListener(fListener);
+ if (provider instanceof IAnalysisModule) {
+ ((IAnalysisModule) provider).schedule();
+ }
}
/**
- * Returns the segment store analysis module
+ * Returns the segment store provider
+ *
* @param trace
* The trace to consider
- * @return the segment store analysis module
+ * @return the segment store provider
*/
- protected @Nullable abstract AbstractSegmentStoreAnalysisModule getSegmentStoreAnalysisModule(ITmfTrace trace);
+ protected @Nullable abstract ISegmentStoreProvider getSegmentStoreProvider(ITmfTrace trace);
@Override
protected void appendToTablePopupMenu(IMenuManager manager, IStructuredSelection sel) {
IAction gotoStartTime = new Action(Messages.SegmentStoreTableViewer_goToStartEvent) {
@Override
public void run() {
- broadcast(new TmfSelectionRangeUpdatedSignal(AbstractSegmentStoreTableViewer.this, new TmfNanoTimestamp(segment.getStart())));
+ broadcast(new TmfSelectionRangeUpdatedSignal(AbstractSegmentStoreTableViewer.this, TmfTimestamp.fromNanos(segment.getStart())));
}
};
IAction gotoEndTime = new Action(Messages.SegmentStoreTableViewer_goToEndEvent) {
@Override
public void run() {
- broadcast(new TmfSelectionRangeUpdatedSignal(AbstractSegmentStoreTableViewer.this, new TmfNanoTimestamp(segment.getEnd())));
+ broadcast(new TmfSelectionRangeUpdatedSignal(AbstractSegmentStoreTableViewer.this, TmfTimestamp.fromNanos(segment.getEnd())));
}
};
// ------------------------------------------------------------------------
/**
- * Get current segment store analysis module
+ * Get current segment store provider
*
- * @return current segment store analysis module
+ * @return current segment store provider
*/
- public @Nullable AbstractSegmentStoreAnalysisModule getAnalysisModule() {
- return fAnalysisModule;
+ public @Nullable ISegmentStoreProvider getSegmentProvider() {
+ return fSegmentProvider;
}
// ------------------------------------------------------------------------
public void traceSelected(TmfTraceSelectedSignal signal) {
ITmfTrace trace = signal.getTrace();
if (trace != null) {
- setData(getSegmentStoreAnalysisModule(trace));
+ setData(getSegmentStoreProvider(trace));
}
}
public void traceOpened(TmfTraceOpenedSignal signal) {
ITmfTrace trace = signal.getTrace();
if (trace != null) {
- setData(getSegmentStoreAnalysisModule(trace));
+ setData(getSegmentStoreProvider(trace));
}
}
refresh();
}
- AbstractSegmentStoreAnalysisModule analysis = getAnalysisModule();
- if ((analysis != null)) {
- analysis.removeListener(fListener);
+ ISegmentStoreProvider provider = getSegmentProvider();
+ if ((provider != null)) {
+ provider.removeListener(fListener);
}
}
}
projects / deliverable / tracecompass.git / blobdiff