-/*******************************************************************************\r
- * Copyright (c) 2010 Ericsson\r
- * \r
- * All rights reserved. This program and the accompanying materials are\r
- * made available under the terms of the Eclipse Public License v1.0 which\r
- * accompanies this distribution, and is available at\r
- * http://www.eclipse.org/legal/epl-v10.html\r
- * \r
- * Contributors:\r
- * Patrick Tasse - Initial API and implementation\r
- *******************************************************************************/\r
-\r
-package org.eclipse.linuxtools.tmf.ui.editors;\r
-\r
-import java.io.FileNotFoundException;\r
-import java.lang.reflect.Constructor;\r
-import java.lang.reflect.InvocationTargetException;\r
-import java.util.List;\r
-\r
-import org.eclipse.core.resources.IMarker;\r
-import org.eclipse.core.resources.IMarkerDelta;\r
-import org.eclipse.core.resources.IResource;\r
-import org.eclipse.core.resources.IResourceChangeEvent;\r
-import org.eclipse.core.resources.IResourceChangeListener;\r
-import org.eclipse.core.resources.IResourceDelta;\r
-import org.eclipse.core.resources.ResourcesPlugin;\r
-import org.eclipse.core.runtime.CoreException;\r
-import org.eclipse.core.runtime.IConfigurationElement;\r
-import org.eclipse.core.runtime.IProgressMonitor;\r
-import org.eclipse.core.runtime.InvalidRegistryObjectException;\r
-import org.eclipse.core.runtime.Platform;\r
-import org.eclipse.linuxtools.tmf.core.event.TmfEvent;\r
-import org.eclipse.linuxtools.tmf.core.experiment.TmfExperiment;\r
-import org.eclipse.linuxtools.tmf.core.signal.TmfSignalHandler;\r
-import org.eclipse.linuxtools.tmf.core.signal.TmfTraceSelectedSignal;\r
-import org.eclipse.linuxtools.tmf.core.trace.ITmfTrace;\r
-import org.eclipse.linuxtools.tmf.core.trace.TmfTrace;\r
-import org.eclipse.linuxtools.tmf.core.util.TmfTraceType;\r
-import org.eclipse.linuxtools.tmf.ui.parsers.custom.CustomEventsTable;\r
-import org.eclipse.linuxtools.tmf.ui.parsers.custom.CustomTxtTrace;\r
-import org.eclipse.linuxtools.tmf.ui.parsers.custom.CustomXmlTrace;\r
-import org.eclipse.linuxtools.tmf.ui.project.handlers.Messages;\r
-import org.eclipse.linuxtools.tmf.ui.project.model.ITmfProjectModelElement;\r
-import org.eclipse.linuxtools.tmf.ui.project.model.TmfExperimentElement;\r
-import org.eclipse.linuxtools.tmf.ui.project.model.TmfNavigatorContentProvider;\r
-import org.eclipse.linuxtools.tmf.ui.project.model.TmfProjectElement;\r
-import org.eclipse.linuxtools.tmf.ui.project.model.TmfProjectRegistry;\r
-import org.eclipse.linuxtools.tmf.ui.project.model.TmfTraceElement;\r
-import org.eclipse.linuxtools.tmf.ui.signal.TmfTraceClosedSignal;\r
-import org.eclipse.linuxtools.tmf.ui.signal.TmfTraceOpenedSignal;\r
-import org.eclipse.linuxtools.tmf.ui.signal.TmfTraceParserUpdatedSignal;\r
-import org.eclipse.linuxtools.tmf.ui.viewers.events.TmfEventsTable;\r
-import org.eclipse.swt.widgets.Composite;\r
-import org.eclipse.swt.widgets.Display;\r
-import org.eclipse.ui.IEditorInput;\r
-import org.eclipse.ui.IEditorPart;\r
-import org.eclipse.ui.IEditorSite;\r
-import org.eclipse.ui.IFileEditorInput;\r
-import org.eclipse.ui.IPropertyListener;\r
-import org.eclipse.ui.IReusableEditor;\r
-import org.eclipse.ui.PartInitException;\r
-import org.eclipse.ui.ide.IGotoMarker;\r
-import org.osgi.framework.Bundle;\r
-\r
-/**\r
- * <b><u>TmfEventsEditor</u></b>\r
- */\r
-public class TmfEventsEditor extends TmfEditor implements ITmfTraceEditor, IReusableEditor, IPropertyListener, IResourceChangeListener {\r
-\r
- public static final String ID = "org.eclipse.linuxtools.tmf.ui.editors.events"; //$NON-NLS-1$\r
- \r
- private TmfEventsTable fEventsTable;\r
- private IResource fResource;\r
- @SuppressWarnings("rawtypes")\r
- private ITmfTrace fTrace;\r
- private Composite fParent;\r
-\r
- @Override\r
- public void doSave(IProgressMonitor monitor) {\r
- }\r
-\r
- @Override\r
- public void doSaveAs() {\r
- }\r
-\r
- @SuppressWarnings({ "unchecked", "rawtypes" })\r
- @Override\r
- public void init(IEditorSite site, IEditorInput input) throws PartInitException {\r
- if (input instanceof TmfEditorInput) {\r
- fResource = ((TmfEditorInput) input).getResource();\r
- fTrace = ((TmfEditorInput) input).getTrace();\r
- } else if (input instanceof IFileEditorInput) {\r
- fResource = ((IFileEditorInput) input).getFile();\r
- if (fResource == null) {\r
- throw new PartInitException("Invalid IFileEditorInput: " + input); //$NON-NLS-1$\r
- }\r
- try {\r
- String traceTypeId = fResource.getPersistentProperty(TmfTraceElement.TRACETYPE);\r
- if (traceTypeId == null) {\r
- throw new PartInitException(Messages.OpenTraceHandler_NoTraceType);\r
- }\r
- if (traceTypeId.equals(TmfExperiment.class.getCanonicalName())) {\r
- // Special case: experiment bookmark resource\r
- TmfNavigatorContentProvider ncp = new TmfNavigatorContentProvider();\r
- ncp.getChildren(fResource.getProject()); // force the model to be populated\r
- TmfProjectElement project = TmfProjectRegistry.getProject(fResource.getProject());\r
- if (project == null) {\r
- throw new PartInitException(Messages.OpenExperimentHandler_NoTraceType);\r
- }\r
- for (ITmfProjectModelElement projectElement : project.getExperimentsFolder().getChildren()) {\r
- String traceName = fResource.getParent().getName();\r
- if (projectElement.getName().equals(traceName)) {\r
- TmfExperimentElement experimentElement = (TmfExperimentElement) projectElement;\r
- // Instantiate the experiment's traces\r
- List<TmfTraceElement> traceEntries = experimentElement.getTraces();\r
- int nbTraces = traceEntries.size();\r
- int cacheSize = Integer.MAX_VALUE;\r
- ITmfTrace<?>[] traces = new ITmfTrace[nbTraces];\r
- for (int i = 0; i < nbTraces; i++) {\r
- TmfTraceElement traceElement = traceEntries.get(i);\r
- ITmfTrace trace = traceElement.instantiateTrace();\r
- TmfEvent traceEvent = traceElement.instantiateEvent();\r
- if (trace == null || traceEvent == null) {\r
- for (int j = 0; j < i; j++) {\r
- traces[j].dispose();\r
- }\r
- throw new PartInitException(Messages.OpenExperimentHandler_NoTraceType);\r
- }\r
- try {\r
- trace.initTrace(traceElement.getLocation().getPath(), traceEvent.getClass(), false);\r
- } catch (FileNotFoundException e) {\r
- }\r
- if (trace instanceof TmfTrace) {\r
- ((TmfTrace) trace).setResource(traceElement.getResource());\r
- }\r
- cacheSize = Math.min(cacheSize, trace.getCacheSize());\r
- traces[i] = trace;\r
- }\r
- TmfExperiment experiment = new TmfExperiment(TmfEvent.class, experimentElement.getName(), traces, cacheSize);\r
- experiment.setResource(fResource);\r
- fTrace = experiment;\r
- experiment.initTrace(null, null, true);\r
- break;\r
- }\r
- }\r
- } else if (traceTypeId.equals(TmfTrace.class.getCanonicalName())) {\r
- // Special case: trace bookmark resource\r
- TmfNavigatorContentProvider ncp = new TmfNavigatorContentProvider();\r
- ncp.getChildren(fResource.getProject()); // force the model to be populated\r
- TmfProjectElement project = TmfProjectRegistry.getProject(fResource.getProject());\r
- for (ITmfProjectModelElement projectElement : project.getTracesFolder().getChildren()) {\r
- String traceName = fResource.getParent().getName();\r
- if (projectElement.getName().equals(traceName)) {\r
- TmfTraceElement traceElement = (TmfTraceElement) projectElement;\r
- // Instantiate the trace\r
- ITmfTrace trace = traceElement.instantiateTrace();\r
- TmfEvent traceEvent = traceElement.instantiateEvent();\r
- if (trace == null || traceEvent == null) {\r
- throw new PartInitException(Messages.OpenTraceHandler_NoTraceType);\r
- }\r
- try {\r
- trace.initTrace(traceElement.getLocation().getPath(), traceEvent.getClass(), true);\r
- } catch (FileNotFoundException e) {\r
- }\r
- if (trace instanceof TmfTrace) {\r
- ((TmfTrace) trace).setResource(traceElement.getResource());\r
- }\r
- fTrace = trace;\r
- break;\r
- }\r
- }\r
- } else {\r
- TmfNavigatorContentProvider ncp = new TmfNavigatorContentProvider();\r
- ncp.getChildren(fResource.getProject()); // force the model to be populated\r
- TmfProjectElement project = TmfProjectRegistry.getProject(fResource.getProject());\r
- for (ITmfProjectModelElement projectElement : project.getTracesFolder().getChildren()) {\r
- if (projectElement.getResource().equals(fResource)) {\r
- TmfTraceElement traceElement = (TmfTraceElement) projectElement;\r
- // Instantiate the trace\r
- ITmfTrace trace = traceElement.instantiateTrace();\r
- TmfEvent traceEvent = traceElement.instantiateEvent();\r
- if (trace == null || traceEvent == null) {\r
- throw new PartInitException(Messages.OpenTraceHandler_NoTraceType);\r
- }\r
- try {\r
- trace.initTrace(traceElement.getLocation().getPath(), traceEvent.getClass(), true);\r
- } catch (FileNotFoundException e) {\r
- }\r
- if (trace instanceof TmfTrace) {\r
- ((TmfTrace) trace).setResource(traceElement.getResource());\r
- }\r
- fTrace = trace;\r
- break;\r
- }\r
- }\r
- }\r
- } catch (InvalidRegistryObjectException e) {\r
- e.printStackTrace();\r
- } catch (PartInitException e) {\r
- throw e;\r
- } catch (CoreException e) {\r
- e.printStackTrace();\r
- }\r
- input = new TmfEditorInput(fResource, fTrace);\r
- } else {\r
- throw new PartInitException("Invalid IEditorInput: " + input.getClass()); //$NON-NLS-1$\r
- }\r
- if (fTrace == null) {\r
- throw new PartInitException("Invalid IEditorInput: " + fResource.getName()); //$NON-NLS-1$\r
- }\r
- super.setSite(site);\r
- super.setInput(input);\r
- }\r
-\r
- @Override\r
- public boolean isDirty() {\r
- return false;\r
- }\r
-\r
- @Override\r
- public boolean isSaveAsAllowed() {\r
- return false;\r
- }\r
-\r
- @Override\r
- public void setInput(IEditorInput input) {\r
- super.setInput(input);\r
- firePropertyChange(IEditorPart.PROP_INPUT);\r
- }\r
-\r
- @Override\r
- public void propertyChanged(Object source, int propId) {\r
- if (propId == IEditorPart.PROP_INPUT) {\r
- broadcast(new TmfTraceClosedSignal(this, fTrace));\r
- fResource = ((TmfEditorInput) getEditorInput()).getResource();\r
- fTrace = ((TmfEditorInput) getEditorInput()).getTrace();\r
- fEventsTable.dispose();\r
- if (fTrace != null) {\r
- fEventsTable = createEventsTable(fParent, fTrace.getCacheSize());\r
- fEventsTable.setTrace(fTrace, true);\r
- fEventsTable.refreshBookmarks(fResource);\r
- broadcast(new TmfTraceOpenedSignal(this, fTrace, fResource, fEventsTable));\r
- } else {\r
- fEventsTable = new TmfEventsTable(fParent, 0);\r
- }\r
- fParent.layout();\r
- }\r
- }\r
-\r
- @Override\r
- public void createPartControl(Composite parent) {\r
- fParent = parent;\r
- setPartName(getEditorInput().getName());\r
- if (fTrace != null) {\r
- fEventsTable = createEventsTable(parent, fTrace.getCacheSize());\r
- fEventsTable.setTrace(fTrace, true);\r
- fEventsTable.refreshBookmarks(fResource);\r
- broadcast(new TmfTraceOpenedSignal(this, fTrace, fResource, fEventsTable));\r
- } else {\r
- fEventsTable = new TmfEventsTable(parent, 0);\r
- }\r
- addPropertyListener(this);\r
- ResourcesPlugin.getWorkspace().addResourceChangeListener(this, IResourceChangeEvent.POST_CHANGE);\r
- }\r
-\r
- @Override\r
- public void dispose() {\r
- ResourcesPlugin.getWorkspace().removeResourceChangeListener(this);\r
- removePropertyListener(this);\r
- if (fTrace != null) {\r
- broadcast(new TmfTraceClosedSignal(this, fTrace));\r
- }\r
- if (fEventsTable != null) {\r
- fEventsTable.dispose();\r
- }\r
- super.dispose();\r
- }\r
-\r
- protected TmfEventsTable createEventsTable(Composite parent, int cacheSize) {\r
- TmfEventsTable eventsTable = getEventsTable(parent, cacheSize);\r
- if (eventsTable == null) {\r
- eventsTable = new TmfEventsTable(parent, cacheSize);\r
- }\r
- return eventsTable;\r
- }\r
- \r
- private TmfEventsTable getEventsTable(Composite parent, int cacheSize) {\r
- if (fTrace instanceof TmfExperiment) {\r
- return getExperimentEventsTable((TmfExperiment<?>) fTrace, parent, cacheSize);\r
- }\r
- TmfEventsTable eventsTable = null;\r
- try {\r
- String traceType = fResource.getPersistentProperty(TmfTraceElement.TRACETYPE);\r
- if (traceType.startsWith(CustomTxtTrace.class.getCanonicalName())) {\r
- return new CustomEventsTable(((CustomTxtTrace) fTrace).getDefinition(), parent, cacheSize);\r
- }\r
- if (traceType.startsWith(CustomXmlTrace.class.getCanonicalName())) {\r
- return new CustomEventsTable(((CustomXmlTrace) fTrace).getDefinition(), parent, cacheSize);\r
- }\r
- for (IConfigurationElement ce : TmfTraceType.getTypeElements()) {\r
- if (ce.getAttribute(TmfTraceType.ID_ATTR).equals(traceType)) {\r
- IConfigurationElement[] eventsTableTypeCE = ce.getChildren(TmfTraceType.EVENTS_TABLE_TYPE_ELEM);\r
- if (eventsTableTypeCE.length != 1) {\r
- break;\r
- }\r
- String eventsTableType = eventsTableTypeCE[0].getAttribute(TmfTraceType.CLASS_ATTR);\r
- if (eventsTableType == null || eventsTableType.length() == 0) {\r
- break;\r
- }\r
- Bundle bundle = Platform.getBundle(ce.getContributor().getName());\r
- Class<?> c = bundle.loadClass(eventsTableType);\r
- Class<?>[] constructorArgs = new Class[] { Composite.class, int.class };\r
- Constructor<?> constructor = c.getConstructor(constructorArgs);\r
- Object[] args = new Object[] { parent, cacheSize };\r
- eventsTable = (TmfEventsTable) constructor.newInstance(args);\r
- break;\r
- }\r
- }\r
- } catch (InvalidRegistryObjectException e) {\r
- e.printStackTrace();\r
- } catch (CoreException e) {\r
- e.printStackTrace();\r
- } catch (ClassNotFoundException e) {\r
- e.printStackTrace();\r
- } catch (SecurityException e) {\r
- e.printStackTrace();\r
- } catch (NoSuchMethodException e) {\r
- e.printStackTrace();\r
- } catch (IllegalArgumentException e) {\r
- e.printStackTrace();\r
- } catch (InstantiationException e) {\r
- e.printStackTrace();\r
- } catch (IllegalAccessException e) {\r
- e.printStackTrace();\r
- } catch (InvocationTargetException e) {\r
- e.printStackTrace();\r
- }\r
- return eventsTable;\r
- }\r
-\r
- /**\r
- * Get the events table for an experiment.\r
- * If all traces in the experiment are of the same type,\r
- * use the extension point specified event table\r
- * @param experiment the experiment\r
- * @param parent the parent Composite\r
- * @param cacheSize the event table cache size\r
- * @return an events table of the appropriate type\r
- */\r
- private TmfEventsTable getExperimentEventsTable(TmfExperiment<?> experiment, Composite parent, int cacheSize) {\r
- TmfEventsTable eventsTable = null;\r
- String commonTraceType = null;\r
- try {\r
- for (ITmfTrace<?> trace : experiment.getTraces()) {\r
- IResource resource = null;\r
- if (trace instanceof TmfTrace) {\r
- resource = ((TmfTrace<?>) trace).getResource();\r
- }\r
- if (resource == null) {\r
- return null;\r
- }\r
- String traceType = resource.getPersistentProperty(TmfTraceElement.TRACETYPE);\r
- if (commonTraceType != null && !commonTraceType.equals(traceType)) {\r
- return null;\r
- }\r
- commonTraceType = traceType;\r
- }\r
- if (commonTraceType == null) {\r
- return null;\r
- }\r
- if (commonTraceType.startsWith(CustomTxtTrace.class.getCanonicalName())) {\r
- return new CustomEventsTable(((CustomTxtTrace) experiment.getTraces()[0]).getDefinition(), parent, cacheSize);\r
- }\r
- if (commonTraceType.startsWith(CustomXmlTrace.class.getCanonicalName())) {\r
- return new CustomEventsTable(((CustomXmlTrace) experiment.getTraces()[0]).getDefinition(), parent, cacheSize);\r
- }\r
- for (IConfigurationElement ce : TmfTraceType.getTypeElements()) {\r
- if (ce.getAttribute(TmfTraceType.ID_ATTR).equals(commonTraceType)) {\r
- IConfigurationElement[] eventsTableTypeCE = ce.getChildren(TmfTraceType.EVENTS_TABLE_TYPE_ELEM);\r
- if (eventsTableTypeCE.length != 1) {\r
- break;\r
- }\r
- String eventsTableType = eventsTableTypeCE[0].getAttribute(TmfTraceType.CLASS_ATTR);\r
- if (eventsTableType == null || eventsTableType.length() == 0) {\r
- break;\r
- }\r
- Bundle bundle = Platform.getBundle(ce.getContributor().getName());\r
- Class<?> c = bundle.loadClass(eventsTableType);\r
- Class<?>[] constructorArgs = new Class[] { Composite.class, int.class };\r
- Constructor<?> constructor = c.getConstructor(constructorArgs);\r
- Object[] args = new Object[] { parent, cacheSize };\r
- eventsTable = (TmfEventsTable) constructor.newInstance(args);\r
- break;\r
- }\r
- }\r
- } catch (CoreException e) {\r
- e.printStackTrace();\r
- } catch (InvalidRegistryObjectException e) {\r
- e.printStackTrace();\r
- } catch (SecurityException e) {\r
- e.printStackTrace();\r
- } catch (IllegalArgumentException e) {\r
- e.printStackTrace();\r
- } catch (ClassNotFoundException e) {\r
- e.printStackTrace();\r
- } catch (NoSuchMethodException e) {\r
- e.printStackTrace();\r
- } catch (InstantiationException e) {\r
- e.printStackTrace();\r
- } catch (IllegalAccessException e) {\r
- e.printStackTrace();\r
- } catch (InvocationTargetException e) {\r
- e.printStackTrace();\r
- }\r
- return eventsTable;\r
- }\r
-\r
- @Override\r
- public ITmfTrace<?> getTrace() {\r
- return fTrace;\r
- }\r
-\r
- @Override\r
- public IResource getResource() {\r
- return fResource;\r
- }\r
-\r
- @Override\r
- public void setFocus() {\r
- fEventsTable.setFocus();\r
- if (fTrace != null) {\r
- broadcast(new TmfTraceSelectedSignal(this, fTrace));\r
- }\r
- }\r
-\r
- @Override\r
- @SuppressWarnings("rawtypes")\r
- public Object getAdapter(Class adapter) {\r
- if (IGotoMarker.class.equals(adapter)) {\r
- return fEventsTable;\r
- }\r
- return super.getAdapter(adapter);\r
- }\r
-\r
- @Override\r
- public void resourceChanged(IResourceChangeEvent event) {\r
- for (IMarkerDelta delta : event.findMarkerDeltas(IMarker.BOOKMARK, false)) {\r
- if (delta.getResource().equals(fResource)) {\r
- if (delta.getKind() == IResourceDelta.REMOVED) {\r
- final IMarker bookmark = delta.getMarker();\r
- Display.getDefault().asyncExec(new Runnable() {\r
- @Override\r
- public void run() {\r
- fEventsTable.removeBookmark(bookmark);\r
- }\r
- });\r
- } else if (delta.getKind() == IResourceDelta.CHANGED) {\r
- Display.getDefault().asyncExec(new Runnable() {\r
- @Override\r
- public void run() {\r
- fEventsTable.getTable().refresh();\r
- }\r
- });\r
- }\r
- }\r
- }\r
- }\r
-\r
- // ------------------------------------------------------------------------\r
- // Global commands\r
- // ------------------------------------------------------------------------\r
-\r
- public void addBookmark() {\r
- fEventsTable.addBookmark(fResource);\r
- }\r
- \r
-\r
- // ------------------------------------------------------------------------\r
- // Signal handlers\r
- // ------------------------------------------------------------------------\r
- \r
- @SuppressWarnings("unchecked")\r
- @TmfSignalHandler\r
- public void traceParserUpdated(TmfTraceParserUpdatedSignal signal) {\r
- if (signal.getTraceResource().equals(fResource)) {\r
- broadcast(new TmfTraceClosedSignal(this, fTrace));\r
- try {\r
- fTrace = null;\r
- String traceTypeId = fResource.getPersistentProperty(TmfTraceElement.TRACETYPE);\r
- if (traceTypeId != null) {\r
- for (IConfigurationElement ce : TmfTraceType.getTypeElements()) {\r
- if (traceTypeId.equals(ce.getAttribute(TmfTraceType.ID_ATTR))) {\r
- fTrace = (ITmfTrace<?>) ce.createExecutableExtension(TmfTraceType.TRACE_TYPE_ATTR);\r
- TmfEvent event = (TmfEvent) ce.createExecutableExtension(TmfTraceType.EVENT_TYPE_ATTR);\r
- String path = fResource.getLocationURI().getPath();\r
- fTrace.initTrace(path, event.getClass(), true);\r
- break;\r
- }\r
- }\r
- }\r
- } catch (InvalidRegistryObjectException e) {\r
- e.printStackTrace();\r
- } catch (FileNotFoundException e) {\r
- e.printStackTrace();\r
- } catch (CoreException e) {\r
- e.printStackTrace();\r
- }\r
- fEventsTable.dispose();\r
- if (fTrace != null) {\r
- fEventsTable = createEventsTable(fParent, fTrace.getCacheSize());\r
- fEventsTable.setTrace(fTrace, true);\r
- broadcast(new TmfTraceOpenedSignal(this, fTrace, fResource, fEventsTable));\r
- } else {\r
- fEventsTable = new TmfEventsTable(fParent, 0);\r
- }\r
- fParent.layout();\r
- }\r
- }\r
-\r
- @TmfSignalHandler\r
- public void traceSelected(TmfTraceSelectedSignal signal) {\r
- if (signal.getSource() != this && signal.getTrace().equals(fTrace)) {\r
- getSite().getPage().bringToTop(this);\r
- }\r
- }\r
-\r
-}\r
+/*******************************************************************************
+ * 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
+ * accompanies this distribution, and is available at
+ * http://www.eclipse.org/legal/epl-v10.html
+ *
+ * Contributors:
+ * Patrick Tasse - Initial API and implementation
+ * Geneviève Bastien - Experiment instantiated with experiment type
+ *******************************************************************************/
+
+package org.eclipse.linuxtools.tmf.ui.editors;
+
+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.IMarkerDelta;
+import org.eclipse.core.resources.IResource;
+import org.eclipse.core.resources.IResourceChangeEvent;
+import org.eclipse.core.resources.IResourceChangeListener;
+import org.eclipse.core.resources.IResourceDelta;
+import org.eclipse.core.resources.ResourcesPlugin;
+import org.eclipse.core.runtime.CoreException;
+import org.eclipse.core.runtime.IProgressMonitor;
+import org.eclipse.core.runtime.InvalidRegistryObjectException;
+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.tmf.core.TmfCommonConstants;
+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.Messages;
+import org.eclipse.linuxtools.tmf.ui.project.model.TmfExperimentElement;
+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.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.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, ISelectionProvider, ISelectionChangedListener, IPartListener, IGotoMarker {
+
+ /** ID for this class */
+ public static final String ID = "org.eclipse.linuxtools.tmf.ui.editors.events"; //$NON-NLS-1$
+
+ private TmfEventsTable fEventsTable;
+ 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) {
+ }
+
+ @Override
+ public void doSaveAs() {
+ }
+
+ @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();
+ /* change the input to a FileEditorInput to allow open handlers to find this editor */
+ fileEditorInput = new FileEditorInput(fFile);
+ } else if (input instanceof IFileEditorInput) {
+ 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.TmfOpenTraceHelper_NoTraceType);
+ }
+ if (traceTypeId.equals(TmfExperiment.class.getCanonicalName())) {
+ // Special case: experiment bookmark resource
+ final TmfProjectElement project = TmfProjectRegistry.getProject(fFile.getProject(), true);
+ if (project == null) {
+ throw new PartInitException(Messages.TmfOpenTraceHelper_NoTraceType);
+ }
+ 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 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 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 {
+ throw new PartInitException("Invalid IEditorInput: " + input.getClass()); //$NON-NLS-1$
+ }
+ if (fTrace == null) {
+ throw new PartInitException("Invalid IEditorInput: " + fFile.getName()); //$NON-NLS-1$
+ }
+ super.setSite(site);
+ super.setInput(fileEditorInput);
+ }
+
+ @Override
+ public boolean isDirty() {
+ return false;
+ }
+
+ @Override
+ public boolean isSaveAsAllowed() {
+ return false;
+ }
+
+ @Override
+ public void setInput(final IEditorInput input) {
+ super.setInput(input);
+ firePropertyChange(IEditorPart.PROP_INPUT);
+ }
+
+ @Override
+ public void propertyChanged(final Object source, final int propId) {
+ 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);
+ 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();
+ }
+ }
+
+ @Override
+ public void createPartControl(final Composite parent) {
+ fParent = parent;
+ if (fTrace != null) {
+ setPartName(fTrace.getName());
+ fEventsTable = createEventsTable(parent, fTrace.getCacheSize());
+ fEventsTable.addSelectionChangedListener(this);
+ fEventsTable.setTrace(fTrace, true);
+ fEventsTable.refreshBookmarks(fFile);
+
+ /* ensure start time is set */
+ final ITmfContext context = fTrace.seekEvent(0);
+ fTrace.getNext(context);
+ context.dispose();
+
+ broadcast(new TmfTraceOpenedSignal(this, fTrace, fFile));
+ } else {
+ 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) {
+ broadcast(new TmfTraceClosedSignal(this, fTrace));
+ }
+ if (fEventsTable != null) {
+ fEventsTable.dispose();
+ }
+ super.dispose();
+ }
+
+ /**
+ * 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);
+ }
+
+ /**
+ * 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;
+ }
+
+ /*
+ * 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);
+ }
+
+ /*
+ * 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 same behavior as if it was one trace of
+ * that type.
+ *
+ * @param experiment
+ * the experiment
+ * @param parent
+ * the parent Composite
+ * @param cacheSize
+ * the event table cache size
+ * @return An event table of the appropriate type
+ */
+ private static @NonNull TmfEventsTable getExperimentEventTable(
+ final TmfExperiment experiment, final Composite parent,
+ final int cacheSize) {
+
+ 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()) {
+ final IResource resource = trace.getResource();
+ if (resource == null) {
+ return null;
+ }
+
+ final String traceType = resource.getPersistentProperty(TmfCommonConstants.TRACETYPE);
+ if ((commonTraceType != null) && !commonTraceType.equals(traceType)) {
+ return null;
+ }
+ commonTraceType = traceType;
+ }
+ } catch (CoreException e) {
+ /*
+ * One of the traces didn't advertise its type, we can't infer
+ * anything.
+ */
+ return null;
+ }
+ return commonTraceType;
+ }
+
+ @Override
+ public ITmfTrace getTrace() {
+ return fTrace;
+ }
+
+ @Override
+ public void setFocus() {
+ fEventsTable.setFocus();
+ }
+
+ @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)) {
+ if (delta.getResource().equals(fFile)) {
+ if (delta.getKind() == IResourceDelta.REMOVED) {
+ final IMarker bookmark = delta.getMarker();
+ Display.getDefault().asyncExec(new Runnable() {
+ @Override
+ public void run() {
+ fEventsTable.removeBookmark(bookmark);
+ }
+ });
+ } else if (delta.getKind() == IResourceDelta.CHANGED) {
+ Display.getDefault().asyncExec(new Runnable() {
+ @Override
+ public void run() {
+ fEventsTable.getTable().refresh();
+ }
+ });
+ }
+ }
+ }
+ }
+
+ // ------------------------------------------------------------------------
+ // 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
+ // ------------------------------------------------------------------------
+
+ /**
+ * Add a bookmark
+ */
+ public void addBookmark() {
+ fEventsTable.addBookmark(fFile);
+ }
+
+
+ // ------------------------------------------------------------------------
+ // Signal handlers
+ // ------------------------------------------------------------------------
+
+ /**
+ * Handler for the Trace Selected signal
+ *
+ * @param signal The incoming signal
+ */
+ @TmfSignalHandler
+ public void traceSelected(final TmfTraceSelectedSignal signal) {
+ if ((signal.getSource() != this)) {
+ if (signal.getTrace().equals(fTrace)) {
+ getSite().getPage().bringToTop(this);
+ } else {
+ fTraceSelected = false;
+ }
+ }
+ }
+
+ /**
+ * Update the display to use the updated timestamp format
+ *
+ * @param signal the incoming signal
+ * @since 2.0
+ */
+ @TmfSignalHandler
+ public void timestampFormatUpdated(TmfTimestampFormatUpdateSignal signal) {
+ if (fEventsTable != null) {
+ fEventsTable.refresh();
+ }
+ }
+
+}
projects / deliverable / tracecompass.git / blobdiff