/*******************************************************************************
- * Copyright (c) 2010 Ericsson
+ * Copyright (c) 2010, 2014 Ericsson, École Polytechnique de Montréal
*
* All rights reserved. This program and the accompanying materials are
* made available under the terms of the Eclipse Public License v1.0 which
*
* Contributors:
* Patrick Tasse - Initial API and implementation
+ * Geneviève Bastien - Experiment instantiated with experiment type
*******************************************************************************/
package org.eclipse.linuxtools.tmf.ui.editors;
-import java.lang.reflect.Constructor;
-import java.lang.reflect.InvocationTargetException;
-import java.util.List;
+import java.util.Collection;
+import java.util.LinkedHashSet;
+import java.util.Set;
import org.eclipse.core.resources.IFile;
import org.eclipse.core.resources.IMarker;
import org.eclipse.core.resources.IResourceDelta;
import org.eclipse.core.resources.ResourcesPlugin;
import org.eclipse.core.runtime.CoreException;
-import org.eclipse.core.runtime.IConfigurationElement;
import org.eclipse.core.runtime.IProgressMonitor;
import org.eclipse.core.runtime.InvalidRegistryObjectException;
-import org.eclipse.core.runtime.Platform;
+import org.eclipse.core.runtime.ListenerList;
+import org.eclipse.jdt.annotation.NonNull;
+import org.eclipse.jdt.annotation.Nullable;
+import org.eclipse.jface.action.IStatusLineManager;
+import org.eclipse.jface.util.SafeRunnable;
+import org.eclipse.jface.viewers.ISelection;
+import org.eclipse.jface.viewers.ISelectionChangedListener;
+import org.eclipse.jface.viewers.ISelectionProvider;
+import org.eclipse.jface.viewers.SelectionChangedEvent;
+import org.eclipse.jface.viewers.StructuredSelection;
import org.eclipse.linuxtools.internal.tmf.ui.Activator;
-import org.eclipse.linuxtools.internal.tmf.ui.parsers.custom.CustomEventsTable;
-import org.eclipse.linuxtools.internal.tmf.ui.parsers.custom.CustomTxtTrace;
-import org.eclipse.linuxtools.internal.tmf.ui.parsers.custom.CustomXmlTrace;
-import org.eclipse.linuxtools.internal.tmf.ui.project.handlers.Messages;
import org.eclipse.linuxtools.tmf.core.TmfCommonConstants;
-import org.eclipse.linuxtools.tmf.core.event.ITmfEvent;
-import org.eclipse.linuxtools.tmf.core.event.TmfEvent;
-import org.eclipse.linuxtools.tmf.core.event.TmfTimeRange;
-import org.eclipse.linuxtools.tmf.core.exceptions.TmfTraceException;
import org.eclipse.linuxtools.tmf.core.signal.TmfSignalHandler;
+import org.eclipse.linuxtools.tmf.core.signal.TmfTimestampFormatUpdateSignal;
+import org.eclipse.linuxtools.tmf.core.signal.TmfTraceClosedSignal;
+import org.eclipse.linuxtools.tmf.core.signal.TmfTraceOpenedSignal;
import org.eclipse.linuxtools.tmf.core.signal.TmfTraceSelectedSignal;
+import org.eclipse.linuxtools.tmf.core.trace.ITmfContext;
import org.eclipse.linuxtools.tmf.core.trace.ITmfTrace;
import org.eclipse.linuxtools.tmf.core.trace.TmfExperiment;
import org.eclipse.linuxtools.tmf.core.trace.TmfTrace;
-import org.eclipse.linuxtools.tmf.ui.project.model.ITmfProjectModelElement;
+import org.eclipse.linuxtools.tmf.ui.project.model.Messages;
import org.eclipse.linuxtools.tmf.ui.project.model.TmfExperimentElement;
-import org.eclipse.linuxtools.tmf.ui.project.model.TmfNavigatorContentProvider;
+import org.eclipse.linuxtools.tmf.ui.project.model.TmfOpenTraceHelper;
import org.eclipse.linuxtools.tmf.ui.project.model.TmfProjectElement;
import org.eclipse.linuxtools.tmf.ui.project.model.TmfProjectRegistry;
import org.eclipse.linuxtools.tmf.ui.project.model.TmfTraceElement;
-import org.eclipse.linuxtools.tmf.ui.project.model.TmfTraceType;
-import org.eclipse.linuxtools.tmf.ui.signal.TmfTraceClosedSignal;
-import org.eclipse.linuxtools.tmf.ui.signal.TmfTraceOpenedSignal;
-import org.eclipse.linuxtools.tmf.ui.signal.TmfTraceParserUpdatedSignal;
+import org.eclipse.linuxtools.tmf.ui.project.model.TmfTraceTypeUIUtils;
import org.eclipse.linuxtools.tmf.ui.viewers.events.TmfEventsTable;
+import org.eclipse.linuxtools.tmf.ui.viewers.events.columns.TmfEventTableColumn;
import org.eclipse.swt.widgets.Composite;
import org.eclipse.swt.widgets.Display;
import org.eclipse.ui.IEditorInput;
import org.eclipse.ui.IEditorPart;
import org.eclipse.ui.IEditorSite;
import org.eclipse.ui.IFileEditorInput;
+import org.eclipse.ui.IPartListener;
import org.eclipse.ui.IPropertyListener;
import org.eclipse.ui.IReusableEditor;
+import org.eclipse.ui.IWorkbenchPart;
import org.eclipse.ui.PartInitException;
import org.eclipse.ui.ide.IGotoMarker;
import org.eclipse.ui.part.FileEditorInput;
-import org.osgi.framework.Bundle;
+import org.eclipse.ui.views.properties.IPropertySheetPage;
/**
* Editor for TMF events
*
* @version 1.0
* @author Patrick Tasse
+ * @since 2.0
*/
-public class TmfEventsEditor extends TmfEditor implements ITmfTraceEditor, IReusableEditor, IPropertyListener, IResourceChangeListener {
+public class TmfEventsEditor extends TmfEditor implements ITmfTraceEditor, IReusableEditor, IPropertyListener, IResourceChangeListener, ISelectionProvider, ISelectionChangedListener, IPartListener, IGotoMarker {
/** ID for this class */
public static final String ID = "org.eclipse.linuxtools.tmf.ui.editors.events"; //$NON-NLS-1$
private IFile fFile;
private ITmfTrace fTrace;
private Composite fParent;
+ private ListenerList fSelectionChangedListeners = new ListenerList();
+ private boolean fTraceSelected;
+ private IMarker fPendingGotoMarker;
@Override
public void doSave(final IProgressMonitor monitor) {
public void doSaveAs() {
}
- @SuppressWarnings({ "unchecked", "rawtypes" })
@Override
public void init(final IEditorSite site, IEditorInput input) throws PartInitException {
+ IFileEditorInput fileEditorInput;
if (input instanceof TmfEditorInput) {
fFile = ((TmfEditorInput) input).getFile();
fTrace = ((TmfEditorInput) input).getTrace();
- input = new FileEditorInput(fFile);
+ /* change the input to a FileEditorInput to allow open handlers to find this editor */
+ fileEditorInput = new FileEditorInput(fFile);
} else if (input instanceof IFileEditorInput) {
- fFile = ((IFileEditorInput) input).getFile();
- if (fFile == null)
- {
- throw new PartInitException("Invalid IFileEditorInput: " + input); //$NON-NLS-1$
+ fileEditorInput = (IFileEditorInput) input;
+ fFile = fileEditorInput.getFile();
+ if (fFile == null) {
+ throw new PartInitException("Invalid IFileEditorInput: " + fileEditorInput); //$NON-NLS-1$
}
try {
final String traceTypeId = fFile.getPersistentProperty(TmfCommonConstants.TRACETYPE);
if (traceTypeId == null) {
- throw new PartInitException(Messages.OpenTraceHandler_NoTraceType);
+ throw new PartInitException(Messages.TmfOpenTraceHelper_NoTraceType);
}
if (traceTypeId.equals(TmfExperiment.class.getCanonicalName())) {
// Special case: experiment bookmark resource
- final TmfNavigatorContentProvider ncp = new TmfNavigatorContentProvider();
- ncp.getChildren(fFile.getProject()); // force the model to be populated
- final TmfProjectElement project = TmfProjectRegistry.getProject(fFile.getProject());
+ final TmfProjectElement project = TmfProjectRegistry.getProject(fFile.getProject(), true);
if (project == null) {
- throw new PartInitException(Messages.OpenExperimentHandler_NoTraceType);
+ throw new PartInitException(Messages.TmfOpenTraceHelper_NoTraceType);
}
- for (final ITmfProjectModelElement projectElement : project.getExperimentsFolder().getChildren()) {
- final String traceName = fFile.getParent().getName();
- if (projectElement.getName().equals(traceName)) {
- final TmfExperimentElement experimentElement = (TmfExperimentElement) projectElement;
- // Instantiate the experiment's traces
- final List<TmfTraceElement> traceEntries = experimentElement.getTraces();
- final int nbTraces = traceEntries.size();
- int cacheSize = Integer.MAX_VALUE;
- final ITmfTrace[] traces = new ITmfTrace[nbTraces];
- for (int i = 0; i < nbTraces; i++) {
- final TmfTraceElement traceElement = traceEntries.get(i);
- final ITmfTrace trace = traceElement.instantiateTrace();
- final ITmfEvent traceEvent = traceElement.instantiateEvent();
- if ((trace == null) || (traceEvent == null)) {
- for (int j = 0; j < i; j++) {
- traces[j].dispose();
- }
- throw new PartInitException(Messages.OpenExperimentHandler_NoTraceType);
- }
- try {
- trace.initTrace(traceElement.getResource(), traceElement.getLocation().getPath(), traceEvent.getClass());
- } catch (final TmfTraceException e) {
- }
- cacheSize = Math.min(cacheSize, trace.getCacheSize());
- traces[i] = trace;
- }
- final TmfExperiment experiment = new TmfExperiment(ITmfEvent.class, experimentElement.getName(), traces, cacheSize) {
- @Override
- public void initTrace(IResource resource, String path, Class type) {
- super.initTrace(resource, path, type);
- getIndexer().buildIndex(getNbEvents(), TmfTimeRange.ETERNITY, false);
- }
- };
- experiment.setBookmarksFile(fFile);
- fTrace = experiment;
- experiment.initTrace(null, null, null);
- break;
+ for (final TmfExperimentElement experimentElement : project.getExperimentsFolder().getExperiments()) {
+ if (experimentElement.getResource().equals(fFile.getParent())) {
+ setPartName(experimentElement.getName());
+ super.setSite(site);
+ super.setInput(fileEditorInput);
+ TmfOpenTraceHelper.reopenTraceFromElement(experimentElement, this);
+ return;
}
}
} else if (traceTypeId.equals(TmfTrace.class.getCanonicalName())) {
// Special case: trace bookmark resource
- final TmfNavigatorContentProvider ncp = new TmfNavigatorContentProvider();
- ncp.getChildren(fFile.getProject()); // force the model to be populated
- final TmfProjectElement project = TmfProjectRegistry.getProject(fFile.getProject());
- for (final ITmfProjectModelElement projectElement : project.getTracesFolder().getChildren()) {
- final String traceName = fFile.getParent().getName();
- if (projectElement.getName().equals(traceName)) {
- final TmfTraceElement traceElement = (TmfTraceElement) projectElement;
- // Instantiate the trace
- final ITmfTrace trace = traceElement.instantiateTrace();
- final ITmfEvent traceEvent = traceElement.instantiateEvent();
- if ((trace == null) || (traceEvent == null)) {
- throw new PartInitException(Messages.OpenTraceHandler_NoTraceType);
- }
- try {
- trace.initTrace(traceElement.getResource(), traceElement.getLocation().getPath(), traceEvent.getClass());
- } catch (final TmfTraceException e) {
- }
- fTrace = trace;
- break;
+ final TmfProjectElement project = TmfProjectRegistry.getProject(fFile.getProject(), true);
+ for (final TmfTraceElement traceElement : project.getTracesFolder().getTraces()) {
+ if (traceElement.getResource().equals(fFile.getParent())) {
+ setPartName(traceElement.getName());
+ super.setSite(site);
+ super.setInput(fileEditorInput);
+ TmfOpenTraceHelper.reopenTraceFromElement(traceElement, this);
+ return;
}
}
} else {
- final TmfNavigatorContentProvider ncp = new TmfNavigatorContentProvider();
- ncp.getChildren(fFile.getProject()); // force the model to be populated
- final TmfProjectElement project = TmfProjectRegistry.getProject(fFile.getProject());
- for (final ITmfProjectModelElement projectElement : project.getTracesFolder().getChildren()) {
- if (projectElement.getResource().equals(fFile)) {
- final TmfTraceElement traceElement = (TmfTraceElement) projectElement;
- // Instantiate the trace
- final ITmfTrace trace = traceElement.instantiateTrace();
- final ITmfEvent traceEvent = traceElement.instantiateEvent();
- if ((trace == null) || (traceEvent == null)) {
- throw new PartInitException(Messages.OpenTraceHandler_NoTraceType);
- }
- try {
- trace.initTrace(traceElement.getResource(), traceElement.getLocation().getPath(), traceEvent.getClass());
- } catch (final TmfTraceException e) {
- }
- fTrace = trace;
- break;
+ final TmfProjectElement project = TmfProjectRegistry.getProject(fFile.getProject(), true);
+ for (final TmfTraceElement traceElement : project.getTracesFolder().getTraces()) {
+ if (traceElement.getResource().equals(fFile)) {
+ setPartName(traceElement.getName());
+ super.setSite(site);
+ super.setInput(fileEditorInput);
+ TmfOpenTraceHelper.reopenTraceFromElement(traceElement, this);
+ return;
}
}
}
+ } catch (final PartInitException e) {
+ throw e;
} catch (final InvalidRegistryObjectException e) {
Activator.getDefault().logError("Error initializing TmfEventsEditor", e); //$NON-NLS-1$
} catch (final CoreException e) {
Activator.getDefault().logError("Error initializing TmfEventsEditor", e); //$NON-NLS-1$
}
- }
- else {
+ } else {
throw new PartInitException("Invalid IEditorInput: " + input.getClass()); //$NON-NLS-1$
}
- if (fTrace == null)
- {
+ if (fTrace == null) {
throw new PartInitException("Invalid IEditorInput: " + fFile.getName()); //$NON-NLS-1$
}
super.setSite(site);
- super.setInput(input);
+ super.setInput(fileEditorInput);
}
@Override
@Override
public void propertyChanged(final Object source, final int propId) {
- if (propId == IEditorPart.PROP_INPUT) {
- broadcast(new TmfTraceClosedSignal(this, fTrace));
+ if (propId == IEditorPart.PROP_INPUT && getEditorInput() instanceof TmfEditorInput) {
+ if (fTrace != null) {
+ broadcast(new TmfTraceClosedSignal(this, fTrace));
+ }
+ fTraceSelected = false;
fFile = ((TmfEditorInput) getEditorInput()).getFile();
fTrace = ((TmfEditorInput) getEditorInput()).getTrace();
+ /* change the input to a FileEditorInput to allow open handlers to find this editor */
super.setInput(new FileEditorInput(fFile));
fEventsTable.dispose();
if (fTrace != null) {
+ setPartName(fTrace.getName());
fEventsTable = createEventsTable(fParent, fTrace.getCacheSize());
+ fEventsTable.addSelectionChangedListener(this);
fEventsTable.setTrace(fTrace, true);
fEventsTable.refreshBookmarks(fFile);
- broadcast(new TmfTraceOpenedSignal(this, fTrace, fFile, fEventsTable));
+ if (fPendingGotoMarker != null) {
+ fEventsTable.gotoMarker(fPendingGotoMarker);
+ fPendingGotoMarker = null;
+ }
+
+ /* ensure start time is set */
+ final ITmfContext context = fTrace.seekEvent(0);
+ fTrace.getNext(context);
+ context.dispose();
+
+ broadcast(new TmfTraceOpenedSignal(this, fTrace, fFile));
} else {
+ setPartName(getEditorInput().getName());
fEventsTable = new TmfEventsTable(fParent, 0);
+ fEventsTable.addSelectionChangedListener(this);
}
fParent.layout();
}
if (fTrace != null) {
setPartName(fTrace.getName());
fEventsTable = createEventsTable(parent, fTrace.getCacheSize());
+ fEventsTable.addSelectionChangedListener(this);
fEventsTable.setTrace(fTrace, true);
fEventsTable.refreshBookmarks(fFile);
- broadcast(new TmfTraceOpenedSignal(this, fTrace, fFile, fEventsTable));
+
+ /* ensure start time is set */
+ final ITmfContext context = fTrace.seekEvent(0);
+ fTrace.getNext(context);
+ context.dispose();
+
+ broadcast(new TmfTraceOpenedSignal(this, fTrace, fFile));
} else {
- setPartName(getEditorInput().getName());
fEventsTable = new TmfEventsTable(parent, 0);
+ fEventsTable.addSelectionChangedListener(this);
}
+ IStatusLineManager statusLineManager = getEditorSite().getActionBars().getStatusLineManager();
+ fEventsTable.setStatusLineManager(statusLineManager);
addPropertyListener(this);
ResourcesPlugin.getWorkspace().addResourceChangeListener(this, IResourceChangeEvent.POST_CHANGE);
+ // we need to wrap the ISelectionProvider interface in the editor because
+ // the events table can be replaced later while the selection changed listener
+ // is only added once by the platform to the selection provider set here
+ getSite().setSelectionProvider(this);
+ getSite().getPage().addPartListener(this);
}
@Override
public void dispose() {
+ if (getSite() != null) {
+ getSite().getPage().removePartListener(this);
+ }
ResourcesPlugin.getWorkspace().removeResourceChangeListener(this);
removePropertyListener(this);
if (fTrace != null) {
super.dispose();
}
- protected TmfEventsTable createEventsTable(final Composite parent, final int cacheSize) {
- TmfEventsTable eventsTable = getEventsTable(parent, cacheSize);
- if (eventsTable == null) {
- eventsTable = new TmfEventsTable(parent, cacheSize);
- }
- return eventsTable;
+ /**
+ * Create the event table
+ *
+ * @param parent
+ * The parent composite
+ * @param cacheSize
+ * The cache size
+ * @return The event table instance
+ */
+ protected @NonNull TmfEventsTable createEventsTable(final Composite parent, final int cacheSize) {
+ return getEventTable(fTrace, parent, cacheSize);
}
- private TmfEventsTable getEventsTable(final Composite parent, final int cacheSize) {
- if (fTrace instanceof TmfExperiment) {
- return getExperimentEventsTable((TmfExperiment) fTrace, parent, cacheSize);
+ /**
+ * Get the event table for the given trace. It will be of the type defined
+ * by the extension point if applicable, else it will be a default table
+ * with the extension-point-defined columns (if any).
+ *
+ * @param trace
+ * The event table is for this trace
+ * @param parent
+ * The parent composite of the table
+ * @param cacheSize
+ * The cache size to use
+ * @return The event table for the trace
+ */
+ private static @NonNull TmfEventsTable getEventTable(ITmfTrace trace,
+ final Composite parent, final int cacheSize) {
+ if (trace instanceof TmfExperiment) {
+ return getExperimentEventTable((TmfExperiment) trace, parent, cacheSize);
+ }
+
+ TmfEventsTable table = TmfTraceTypeUIUtils.getEventTable(trace, parent, cacheSize);
+ if (table != null) {
+ /*
+ * The trace type specified an event table type, we will give it to
+ * them.
+ */
+ return table;
}
- TmfEventsTable eventsTable = null;
- try {
- if (fTrace.getResource() == null) {
- return null;
- }
- final String traceType = fTrace.getResource().getPersistentProperty(TmfCommonConstants.TRACETYPE);
- if (traceType == null) {
- return null;
- }
- if (traceType.startsWith(CustomTxtTrace.class.getCanonicalName())) {
- return new CustomEventsTable(((CustomTxtTrace) fTrace).getDefinition(), parent, cacheSize);
- }
- if (traceType.startsWith(CustomXmlTrace.class.getCanonicalName())) {
- return new CustomEventsTable(((CustomXmlTrace) fTrace).getDefinition(), parent, cacheSize);
- }
- for (final IConfigurationElement ce : TmfTraceType.getTypeElements()) {
- if (ce.getAttribute(TmfTraceType.ID_ATTR).equals(traceType)) {
- final IConfigurationElement[] eventsTableTypeCE = ce.getChildren(TmfTraceType.EVENTS_TABLE_TYPE_ELEM);
- if (eventsTableTypeCE.length != 1) {
- break;
- }
- final String eventsTableType = eventsTableTypeCE[0].getAttribute(TmfTraceType.CLASS_ATTR);
- if ((eventsTableType == null) || (eventsTableType.length() == 0)) {
- break;
- }
- final Bundle bundle = Platform.getBundle(ce.getContributor().getName());
- final Class<?> c = bundle.loadClass(eventsTableType);
- final Class<?>[] constructorArgs = new Class[] { Composite.class, int.class };
- final Constructor<?> constructor = c.getConstructor(constructorArgs);
- final Object[] args = new Object[] { parent, cacheSize };
- eventsTable = (TmfEventsTable) constructor.newInstance(args);
- break;
- }
- }
- } catch (final InvalidRegistryObjectException e) {
- Activator.getDefault().logError("Error getting TmfEventsTable", e); //$NON-NLS-1$
- } catch (final CoreException e) {
- Activator.getDefault().logError("Error getting TmfEventsTable", e); //$NON-NLS-1$
- } catch (final ClassNotFoundException e) {
- Activator.getDefault().logError("Error getting TmfEventsTable", e); //$NON-NLS-1$
- } catch (final SecurityException e) {
- Activator.getDefault().logError("Error getting TmfEventsTable", e); //$NON-NLS-1$
- } catch (final NoSuchMethodException e) {
- Activator.getDefault().logError("Error getting TmfEventsTable", e); //$NON-NLS-1$
- } catch (final IllegalArgumentException e) {
- Activator.getDefault().logError("Error getting TmfEventsTable", e); //$NON-NLS-1$
- } catch (final InstantiationException e) {
- Activator.getDefault().logError("Error getting TmfEventsTable", e); //$NON-NLS-1$
- } catch (final IllegalAccessException e) {
- Activator.getDefault().logError("Error getting TmfEventsTable", e); //$NON-NLS-1$
- } catch (final InvocationTargetException e) {
- Activator.getDefault().logError("Error getting TmfEventsTable", e); //$NON-NLS-1$
+
+ /*
+ * The trace type did not specify an event table, we will use a default
+ * table with the columns it asked for (if any).
+ */
+ Collection<? extends TmfEventTableColumn> columns = TmfTraceTypeUIUtils.getEventTableColumns(trace);
+ if (columns != null) {
+ return new TmfEventsTable(parent, cacheSize, columns);
}
- return eventsTable;
+
+ /*
+ * No columns were defined either, use a default table with the default
+ * columns.
+ */
+ return new TmfEventsTable(parent, cacheSize);
+
}
/**
* Get the events table for an experiment. If all traces in the experiment
- * are of the same type, use the extension point specified event table
+ * are of the same type, use the same behavior as if it was one trace of
+ * that type.
*
* @param experiment
* the experiment
* the parent Composite
* @param cacheSize
* the event table cache size
- * @return an events table of the appropriate type
+ * @return An event table of the appropriate type
*/
- private static TmfEventsTable getExperimentEventsTable(
+ private static @NonNull TmfEventsTable getExperimentEventTable(
final TmfExperiment experiment, final Composite parent,
final int cacheSize) {
- TmfEventsTable eventsTable = null;
+
+ String commonTraceType = getCommonTraceType(experiment);
+ if (commonTraceType != null) {
+ /*
+ * All the traces in this experiment are of the same type, let's
+ * just use the normal table for that type.
+ */
+ return getEventTable(experiment.getTraces()[0], parent, cacheSize);
+ }
+
+ /*
+ * There are different trace types in the experiment, so we are
+ * definitely using a TmfEventsTable. Aggregate the columns from all
+ * trace types.
+ */
+ ITmfTrace[] traces = experiment.getTraces();
+ Set<TmfEventTableColumn> cols = new LinkedHashSet<>();
+
+ for (ITmfTrace trace : traces) {
+ Collection<? extends TmfEventTableColumn> traceCols =
+ TmfTraceTypeUIUtils.getEventTableColumns(trace);
+ if (traceCols == null) {
+ cols.addAll(TmfEventsTable.DEFAULT_COLUMNS);
+ } else {
+ cols.addAll(traceCols);
+ }
+ }
+
+ return new TmfEventsTable(parent, cacheSize, cols);
+ }
+
+ /**
+ * Check if an experiment contains traces of all the same type. If so,
+ * returns this type as a String. If not, returns null.
+ *
+ * @param experiment
+ * The experiment
+ * @return The common trace type if there is one, or 'null' if there are
+ * different types.
+ */
+ private static @Nullable String getCommonTraceType(TmfExperiment experiment) {
String commonTraceType = null;
try {
for (final ITmfTrace trace : experiment.getTraces()) {
if (resource == null) {
return null;
}
+
final String traceType = resource.getPersistentProperty(TmfCommonConstants.TRACETYPE);
if ((commonTraceType != null) && !commonTraceType.equals(traceType)) {
return null;
}
commonTraceType = traceType;
}
- if (commonTraceType == null) {
- return null;
- }
- if (commonTraceType.startsWith(CustomTxtTrace.class.getCanonicalName())) {
- return new CustomEventsTable(((CustomTxtTrace) experiment.getTraces()[0]).getDefinition(), parent, cacheSize);
- }
- if (commonTraceType.startsWith(CustomXmlTrace.class.getCanonicalName())) {
- return new CustomEventsTable(((CustomXmlTrace) experiment.getTraces()[0]).getDefinition(), parent, cacheSize);
- }
- for (final IConfigurationElement ce : TmfTraceType.getTypeElements()) {
- if (ce.getAttribute(TmfTraceType.ID_ATTR).equals(commonTraceType)) {
- final IConfigurationElement[] eventsTableTypeCE = ce.getChildren(TmfTraceType.EVENTS_TABLE_TYPE_ELEM);
- if (eventsTableTypeCE.length != 1) {
- break;
- }
- final String eventsTableType = eventsTableTypeCE[0].getAttribute(TmfTraceType.CLASS_ATTR);
- if ((eventsTableType == null) || (eventsTableType.length() == 0)) {
- break;
- }
- final Bundle bundle = Platform.getBundle(ce.getContributor().getName());
- final Class<?> c = bundle.loadClass(eventsTableType);
- final Class<?>[] constructorArgs = new Class[] { Composite.class, int.class };
- final Constructor<?> constructor = c.getConstructor(constructorArgs);
- final Object[] args = new Object[] { parent, cacheSize };
- eventsTable = (TmfEventsTable) constructor.newInstance(args);
- break;
- }
- }
- } catch (final CoreException e) {
- Activator.getDefault().logError("Error getting TmfEventsTable for experiment", e); //$NON-NLS-1$
- } catch (final InvalidRegistryObjectException e) {
- Activator.getDefault().logError("Error getting TmfEventsTable for experiment", e); //$NON-NLS-1$
- } catch (final SecurityException e) {
- Activator.getDefault().logError("Error getting TmfEventsTable for experiment", e); //$NON-NLS-1$
- } catch (final IllegalArgumentException e) {
- Activator.getDefault().logError("Error getting TmfEventsTable for experiment", e); //$NON-NLS-1$
- } catch (final ClassNotFoundException e) {
- Activator.getDefault().logError("Error getting TmfEventsTable for experiment", e); //$NON-NLS-1$
- } catch (final NoSuchMethodException e) {
- Activator.getDefault().logError("Error getting TmfEventsTable for experiment", e); //$NON-NLS-1$
- } catch (final InstantiationException e) {
- Activator.getDefault().logError("Error getting TmfEventsTable for experiment", e); //$NON-NLS-1$
- } catch (final IllegalAccessException e) {
- Activator.getDefault().logError("Error getting TmfEventsTable for experiment", e); //$NON-NLS-1$
- } catch (final InvocationTargetException e) {
- Activator.getDefault().logError("Error getting TmfEventsTable for experiment", e); //$NON-NLS-1$
+ } catch (CoreException e) {
+ /*
+ * One of the traces didn't advertise its type, we can't infer
+ * anything.
+ */
+ return null;
}
- return eventsTable;
+ return commonTraceType;
}
@Override
return fTrace;
}
- @Override
- public IFile getBookmarksFile() {
- return fFile;
- }
-
@Override
public void setFocus() {
fEventsTable.setFocus();
- if (fTrace != null) {
- broadcast(new TmfTraceSelectedSignal(this, fTrace));
- }
}
@Override
public Object getAdapter(final Class adapter) {
if (IGotoMarker.class.equals(adapter)) {
+ if (fTrace == null || fEventsTable == null) {
+ return this;
+ }
return fEventsTable;
+ } else if (IPropertySheetPage.class.equals(adapter)) {
+ return new UnsortedPropertySheetPage();
}
return super.getAdapter(adapter);
}
+ /**
+ * @since 2.1
+ */
+ @Override
+ public void gotoMarker(IMarker marker) {
+ if (fTrace == null || fEventsTable == null) {
+ fPendingGotoMarker = marker;
+ } else {
+ fEventsTable.gotoMarker(marker);
+ }
+ }
+
@Override
public void resourceChanged(final IResourceChangeEvent event) {
for (final IMarkerDelta delta : event.findMarkerDeltas(IMarker.BOOKMARK, false)) {
}
}
+ // ------------------------------------------------------------------------
+ // ISelectionProvider
+ // ------------------------------------------------------------------------
+
+ /**
+ * @since 2.0
+ */
+ @Override
+ public void addSelectionChangedListener(ISelectionChangedListener listener) {
+ fSelectionChangedListeners.add(listener);
+ }
+
+ /**
+ * @since 2.0
+ */
+ @Override
+ public ISelection getSelection() {
+ if (fEventsTable == null) {
+ return StructuredSelection.EMPTY;
+ }
+ return fEventsTable.getSelection();
+ }
+
+ /**
+ * @since 2.0
+ */
+ @Override
+ public void removeSelectionChangedListener(ISelectionChangedListener listener) {
+ fSelectionChangedListeners.remove(listener);
+ }
+
+ /**
+ * @since 2.0
+ */
+ @Override
+ public void setSelection(ISelection selection) {
+ // not implemented
+ }
+
+ /**
+ * Notifies any selection changed listeners that the viewer's selection has changed.
+ * Only listeners registered at the time this method is called are notified.
+ *
+ * @param event a selection changed event
+ *
+ * @see ISelectionChangedListener#selectionChanged
+ * @since 2.0
+ */
+ protected void fireSelectionChanged(final SelectionChangedEvent event) {
+ Object[] listeners = fSelectionChangedListeners.getListeners();
+ for (int i = 0; i < listeners.length; ++i) {
+ final ISelectionChangedListener l = (ISelectionChangedListener) listeners[i];
+ SafeRunnable.run(new SafeRunnable() {
+ @Override
+ public void run() {
+ l.selectionChanged(event);
+ }
+ });
+ }
+ }
+
+ // ------------------------------------------------------------------------
+ // ISelectionChangedListener
+ // ------------------------------------------------------------------------
+
+ /**
+ * @since 2.0
+ */
+ @Override
+ public void selectionChanged(SelectionChangedEvent event) {
+ fireSelectionChanged(event);
+ }
+
+ // ------------------------------------------------------------------------
+ // IPartListener
+ // ------------------------------------------------------------------------
+
+ /**
+ * @since 2.0
+ */
+ @Override
+ public void partActivated(IWorkbenchPart part) {
+ if (part == this && fTrace != null) {
+ if (fTraceSelected) {
+ return;
+ }
+ fTraceSelected = true;
+ broadcast(new TmfTraceSelectedSignal(this, fTrace));
+ }
+ }
+
+ /**
+ * @since 2.0
+ */
+ @Override
+ public void partBroughtToTop(IWorkbenchPart part) {
+ if (part == this && fTrace != null) {
+ if (fTraceSelected) {
+ return;
+ }
+ fTraceSelected = true;
+ broadcast(new TmfTraceSelectedSignal(this, fTrace));
+ }
+ }
+
+ /**
+ * @since 2.0
+ */
+ @Override
+ public void partClosed(IWorkbenchPart part) {
+ }
+
+ /**
+ * @since 2.0
+ */
+ @Override
+ public void partDeactivated(IWorkbenchPart part) {
+ }
+
+ /**
+ * @since 2.0
+ */
+ @Override
+ public void partOpened(IWorkbenchPart part) {
+ }
+
// ------------------------------------------------------------------------
// Global commands
// ------------------------------------------------------------------------
// ------------------------------------------------------------------------
/**
- * Handler for the Trace Parser Updated signal
+ * Handler for the Trace Selected signal
*
* @param signal The incoming signal
*/
@TmfSignalHandler
- public void traceParserUpdated(final TmfTraceParserUpdatedSignal signal) {
- if (signal.getTraceResource().equals(fFile)) {
- broadcast(new TmfTraceClosedSignal(this, fTrace));
- try {
- fTrace.getName();
- fTrace = null;
- final String traceTypeId = fFile.getPersistentProperty(TmfCommonConstants.TRACETYPE);
- if (traceTypeId != null) {
- for (final IConfigurationElement ce : TmfTraceType.getTypeElements()) {
- if (traceTypeId.equals(ce.getAttribute(TmfTraceType.ID_ATTR))) {
- fTrace = (ITmfTrace) ce.createExecutableExtension(TmfTraceType.TRACE_TYPE_ATTR);
- final ITmfEvent event = (TmfEvent) ce.createExecutableExtension(TmfTraceType.EVENT_TYPE_ATTR);
- final String path = fFile.getLocationURI().getPath();
- fTrace.initTrace(null, path, event.getClass());
- break;
- }
- }
- }
- } catch (final InvalidRegistryObjectException e) {
- Activator.getDefault().logError("Error handling signal TmfTraceParserUpdatedSignal", e); //$NON-NLS-1$
- } catch (final TmfTraceException e) {
- Activator.getDefault().logError("Error handling signal TmfTraceParserUpdatedSignal", e); //$NON-NLS-1$
- } catch (final CoreException e) {
- Activator.getDefault().logError("Error handling signal TmfTraceParserUpdatedSignal", e); //$NON-NLS-1$
- }
- fEventsTable.dispose();
- if (fTrace != null) {
- fEventsTable = createEventsTable(fParent, fTrace.getCacheSize());
- fEventsTable.setTrace(fTrace, true);
- broadcast(new TmfTraceOpenedSignal(this, fTrace, fFile, fEventsTable));
+ public void traceSelected(final TmfTraceSelectedSignal signal) {
+ if ((signal.getSource() != this)) {
+ if (signal.getTrace().equals(fTrace)) {
+ getSite().getPage().bringToTop(this);
} else {
- fEventsTable = new TmfEventsTable(fParent, 0);
+ fTraceSelected = false;
}
- fParent.layout();
}
}
/**
- * Handler for the Trace Selected signal
+ * Update the display to use the updated timestamp format
*
- * @param signal The incoming signal
+ * @param signal the incoming signal
+ * @since 2.0
*/
@TmfSignalHandler
- public void traceSelected(final TmfTraceSelectedSignal signal) {
- if ((signal.getSource() != this) && signal.getTrace().equals(fTrace)) {
- getSite().getPage().bringToTop(this);
+ public void timestampFormatUpdated(TmfTimestampFormatUpdateSignal signal) {
+ if (fEventsTable != null) {
+ fEventsTable.refresh();
}
}
projects / deliverable / tracecompass.git / blobdiff