org.eclipse.linuxtools.tmf.ui/src/org/eclipse/linuxtools/tmf/ui/editors/TmfEventsEditor.java

   1 /*******************************************************************************
   2  * Copyright (c) 2010 Ericsson
   3  *
   4  * All rights reserved. This program and the accompanying materials are
   5  * made available under the terms of the Eclipse Public License v1.0 which
   6  * accompanies this distribution, and is available at
   7  * http://www.eclipse.org/legal/epl-v10.html
   8  *
   9  * Contributors:
  10  *   Patrick Tasse - Initial API and implementation
  11  *******************************************************************************/
  12
  13 package org.eclipse.linuxtools.tmf.ui.editors;
  14
  15 import java.io.FileNotFoundException;
  16 import java.lang.reflect.Constructor;
  17 import java.lang.reflect.InvocationTargetException;
  18 import java.util.List;
  19
  20 import org.eclipse.core.resources.IFile;
  21 import org.eclipse.core.resources.IMarker;
  22 import org.eclipse.core.resources.IMarkerDelta;
  23 import org.eclipse.core.resources.IResource;
  24 import org.eclipse.core.resources.IResourceChangeEvent;
  25 import org.eclipse.core.resources.IResourceChangeListener;
  26 import org.eclipse.core.resources.IResourceDelta;
  27 import org.eclipse.core.resources.ResourcesPlugin;
  28 import org.eclipse.core.runtime.CoreException;
  29 import org.eclipse.core.runtime.IConfigurationElement;
  30 import org.eclipse.core.runtime.IProgressMonitor;
  31 import org.eclipse.core.runtime.InvalidRegistryObjectException;
  32 import org.eclipse.core.runtime.Platform;
  33 import org.eclipse.linuxtools.internal.tmf.ui.parsers.custom.CustomEventsTable;
  34 import org.eclipse.linuxtools.internal.tmf.ui.parsers.custom.CustomTxtTrace;
  35 import org.eclipse.linuxtools.internal.tmf.ui.parsers.custom.CustomXmlTrace;
  36 import org.eclipse.linuxtools.internal.tmf.ui.project.handlers.Messages;
  37 import org.eclipse.linuxtools.tmf.core.event.ITmfEvent;
  38 import org.eclipse.linuxtools.tmf.core.event.TmfEvent;
  39 import org.eclipse.linuxtools.tmf.core.experiment.TmfExperiment;
  40 import org.eclipse.linuxtools.tmf.core.signal.TmfSignalHandler;
  41 import org.eclipse.linuxtools.tmf.core.signal.TmfTraceSelectedSignal;
  42 import org.eclipse.linuxtools.tmf.core.trace.ITmfTrace;
  43 import org.eclipse.linuxtools.tmf.core.trace.TmfTrace;
  44 import org.eclipse.linuxtools.tmf.ui.project.model.ITmfProjectModelElement;
  45 import org.eclipse.linuxtools.tmf.ui.project.model.TmfExperimentElement;
  46 import org.eclipse.linuxtools.tmf.ui.project.model.TmfNavigatorContentProvider;
  47 import org.eclipse.linuxtools.tmf.ui.project.model.TmfProjectElement;
  48 import org.eclipse.linuxtools.tmf.ui.project.model.TmfProjectRegistry;
  49 import org.eclipse.linuxtools.tmf.ui.project.model.TmfTraceElement;
  50 import org.eclipse.linuxtools.tmf.ui.project.model.TmfTraceType;
  51 import org.eclipse.linuxtools.tmf.ui.signal.TmfTraceClosedSignal;
  52 import org.eclipse.linuxtools.tmf.ui.signal.TmfTraceOpenedSignal;
  53 import org.eclipse.linuxtools.tmf.ui.signal.TmfTraceParserUpdatedSignal;
  54 import org.eclipse.linuxtools.tmf.ui.viewers.events.TmfEventsTable;
  55 import org.eclipse.swt.widgets.Composite;
  56 import org.eclipse.swt.widgets.Display;
  57 import org.eclipse.ui.IEditorInput;
  58 import org.eclipse.ui.IEditorPart;
  59 import org.eclipse.ui.IEditorSite;
  60 import org.eclipse.ui.IFileEditorInput;
  61 import org.eclipse.ui.IPropertyListener;
  62 import org.eclipse.ui.IReusableEditor;
  63 import org.eclipse.ui.PartInitException;
  64 import org.eclipse.ui.ide.IGotoMarker;
  65 import org.eclipse.ui.part.FileEditorInput;
  66 import org.osgi.framework.Bundle;
  67
  68 /**
  69  * <b><u>TmfEventsEditor</u></b>
  70  */
  71 public class TmfEventsEditor extends TmfEditor implements ITmfTraceEditor, IReusableEditor, IPropertyListener, IResourceChangeListener {
  72
  73     public static final String ID = "org.eclipse.linuxtools.tmf.ui.editors.events"; //$NON-NLS-1$
  74
  75     private TmfEventsTable fEventsTable;
  76     private IFile fFile;
  77     @SuppressWarnings("rawtypes")
  78     private ITmfTrace fTrace;
  79     private Composite fParent;
  80
  81     @Override
  82     public void doSave(final IProgressMonitor monitor) {
  83     }
  84
  85     @Override
  86     public void doSaveAs() {
  87     }
  88
  89     @SuppressWarnings({ "unchecked", "rawtypes" })
  90     @Override
  91     public void init(final IEditorSite site, IEditorInput input) throws PartInitException {
  92         if (input instanceof TmfEditorInput) {
  93             fFile = ((TmfEditorInput) input).getFile();
  94             fTrace = ((TmfEditorInput) input).getTrace();
  95             input = new FileEditorInput(fFile);
  96         } else if (input instanceof IFileEditorInput) {
  97             fFile = ((IFileEditorInput) input).getFile();
  98             if (fFile == null)
  99                 throw new PartInitException("Invalid IFileEditorInput: " + input); //$NON-NLS-1$
 100             try {
 101                 final String traceTypeId = fFile.getPersistentProperty(TmfTraceElement.TRACETYPE);
 102                 if (traceTypeId == null)
 103                     throw new PartInitException(Messages.OpenTraceHandler_NoTraceType);
 104                 if (traceTypeId.equals(TmfExperiment.class.getCanonicalName())) {
 105                     // Special case: experiment bookmark resource
 106                     final TmfNavigatorContentProvider ncp = new TmfNavigatorContentProvider();
 107                     ncp.getChildren(fFile.getProject()); // force the model to be populated
 108                     final TmfProjectElement project = TmfProjectRegistry.getProject(fFile.getProject());
 109                     if (project == null)
 110                         throw new PartInitException(Messages.OpenExperimentHandler_NoTraceType);
 111                     for (final ITmfProjectModelElement projectElement : project.getExperimentsFolder().getChildren()) {
 112                         final String traceName = fFile.getParent().getName();
 113                         if (projectElement.getName().equals(traceName)) {
 114                             final TmfExperimentElement experimentElement = (TmfExperimentElement) projectElement;
 115                             // Instantiate the experiment's traces
 116                             final List<TmfTraceElement> traceEntries = experimentElement.getTraces();
 117                             final int nbTraces = traceEntries.size();
 118                             int cacheSize = Integer.MAX_VALUE;
 119                             final ITmfTrace<?>[] traces = new ITmfTrace[nbTraces];
 120                             for (int i = 0; i < nbTraces; i++) {
 121                                 final TmfTraceElement traceElement = traceEntries.get(i);
 122                                 final ITmfTrace trace = traceElement.instantiateTrace();
 123                                 final ITmfEvent traceEvent = traceElement.instantiateEvent();
 124                                 if ((trace == null) || (traceEvent == null)) {
 125                                     for (int j = 0; j < i; j++)
 126                                         traces[j].dispose();
 127                                     throw new PartInitException(Messages.OpenExperimentHandler_NoTraceType);
 128                                 }
 129                                 try {
 130                                     trace.initTrace(traceElement.getResource(), traceElement.getLocation().getPath(), traceEvent.getClass());
 131                                 } catch (final FileNotFoundException e) {
 132                                 }
 133                                 cacheSize = Math.min(cacheSize, trace.getCacheSize());
 134                                 traces[i] = trace;
 135                             }
 136                             final TmfExperiment experiment = new TmfExperiment(ITmfEvent.class, experimentElement.getName(), traces, cacheSize);
 137                             experiment.setBookmarksFile(fFile);
 138                             fTrace = experiment;
 139                             experiment.initTrace(null, null, null);
 140                             break;
 141                         }
 142                     }
 143                 } else if (traceTypeId.equals(TmfTrace.class.getCanonicalName())) {
 144                     // Special case: trace bookmark resource
 145                     final TmfNavigatorContentProvider ncp = new TmfNavigatorContentProvider();
 146                     ncp.getChildren(fFile.getProject()); // force the model to be populated
 147                     final TmfProjectElement project = TmfProjectRegistry.getProject(fFile.getProject());
 148                     for (final ITmfProjectModelElement projectElement : project.getTracesFolder().getChildren()) {
 149                         final String traceName = fFile.getParent().getName();
 150                         if (projectElement.getName().equals(traceName)) {
 151                             final TmfTraceElement traceElement = (TmfTraceElement) projectElement;
 152                             // Instantiate the trace
 153                             final ITmfTrace trace = traceElement.instantiateTrace();
 154                             final ITmfEvent traceEvent = traceElement.instantiateEvent();
 155                             if ((trace == null) || (traceEvent == null))
 156                                 throw new PartInitException(Messages.OpenTraceHandler_NoTraceType);
 157                             try {
 158                                 trace.initTrace(traceElement.getResource(), traceElement.getLocation().getPath(), traceEvent.getClass());
 159                             } catch (final FileNotFoundException e) {
 160                             }
 161                             fTrace = trace;
 162                             break;
 163                         }
 164                     }
 165                 } else {
 166                     final TmfNavigatorContentProvider ncp = new TmfNavigatorContentProvider();
 167                     ncp.getChildren(fFile.getProject()); // force the model to be populated
 168                     final TmfProjectElement project = TmfProjectRegistry.getProject(fFile.getProject());
 169                     for (final ITmfProjectModelElement projectElement : project.getTracesFolder().getChildren())
 170                         if (projectElement.getResource().equals(fFile)) {
 171                             final TmfTraceElement traceElement = (TmfTraceElement) projectElement;
 172                             // Instantiate the trace
 173                             final ITmfTrace trace = traceElement.instantiateTrace();
 174                             final ITmfEvent traceEvent = traceElement.instantiateEvent();
 175                             if ((trace == null) || (traceEvent == null))
 176                                 throw new PartInitException(Messages.OpenTraceHandler_NoTraceType);
 177                             try {
 178                                 trace.initTrace(traceElement.getResource(), traceElement.getLocation().getPath(), traceEvent.getClass());
 179                             } catch (final FileNotFoundException e) {
 180                             }
 181                             fTrace = trace;
 182                             break;
 183                         }
 184                 }
 185             } catch (final InvalidRegistryObjectException e) {
 186                 e.printStackTrace();
 187             } catch (final PartInitException e) {
 188                 throw e;
 189             } catch (final CoreException e) {
 190                 e.printStackTrace();
 191             }
 192         } else
 193             throw new PartInitException("Invalid IEditorInput: " + input.getClass()); //$NON-NLS-1$
 194         if (fTrace == null)
 195             throw new PartInitException("Invalid IEditorInput: " + fFile.getName()); //$NON-NLS-1$
 196         super.setSite(site);
 197         super.setInput(input);
 198     }
 199
 200     @Override
 201     public boolean isDirty() {
 202         return false;
 203     }
 204
 205     @Override
 206     public boolean isSaveAsAllowed() {
 207         return false;
 208     }
 209
 210     @Override
 211     public void setInput(final IEditorInput input) {
 212         super.setInput(input);
 213         firePropertyChange(IEditorPart.PROP_INPUT);
 214     }
 215
 216     @Override
 217     public void propertyChanged(final Object source, final int propId) {
 218         if (propId == IEditorPart.PROP_INPUT) {
 219             broadcast(new TmfTraceClosedSignal(this, fTrace));
 220             fFile = ((TmfEditorInput) getEditorInput()).getFile();
 221             fTrace = ((TmfEditorInput) getEditorInput()).getTrace();
 222             super.setInput(new FileEditorInput(fFile));
 223             fEventsTable.dispose();
 224             if (fTrace != null) {
 225                 fEventsTable = createEventsTable(fParent, fTrace.getCacheSize());
 226                 fEventsTable.setTrace(fTrace, true);
 227                 fEventsTable.refreshBookmarks(fFile);
 228                 broadcast(new TmfTraceOpenedSignal(this, fTrace, fFile, fEventsTable));
 229             } else
 230                 fEventsTable = new TmfEventsTable(fParent, 0);
 231             fParent.layout();
 232         }
 233     }
 234
 235     @Override
 236     public void createPartControl(final Composite parent) {
 237         fParent = parent;
 238         if (fTrace != null) {
 239             setPartName(fTrace.getName());
 240             fEventsTable = createEventsTable(parent, fTrace.getCacheSize());
 241             fEventsTable.setTrace(fTrace, true);
 242             fEventsTable.refreshBookmarks(fFile);
 243             broadcast(new TmfTraceOpenedSignal(this, fTrace, fFile, fEventsTable));
 244         } else {
 245             setPartName(getEditorInput().getName());
 246             fEventsTable = new TmfEventsTable(parent, 0);
 247         }
 248         addPropertyListener(this);
 249         ResourcesPlugin.getWorkspace().addResourceChangeListener(this, IResourceChangeEvent.POST_CHANGE);
 250     }
 251
 252     @Override
 253     public void dispose() {
 254         ResourcesPlugin.getWorkspace().removeResourceChangeListener(this);
 255         removePropertyListener(this);
 256         if (fTrace != null)
 257             broadcast(new TmfTraceClosedSignal(this, fTrace));
 258         if (fEventsTable != null)
 259             fEventsTable.dispose();
 260         super.dispose();
 261     }
 262
 263     protected TmfEventsTable createEventsTable(final Composite parent, final int cacheSize) {
 264         TmfEventsTable eventsTable = getEventsTable(parent, cacheSize);
 265         if (eventsTable == null)
 266             eventsTable = new TmfEventsTable(parent, cacheSize);
 267         return eventsTable;
 268     }
 269
 270     private TmfEventsTable getEventsTable(final Composite parent, final int cacheSize) {
 271         if (fTrace instanceof TmfExperiment)
 272             return getExperimentEventsTable((TmfExperiment<?>) fTrace, parent, cacheSize);
 273         TmfEventsTable eventsTable = null;
 274         try {
 275             if (fTrace.getResource() == null)
 276                 return null;
 277             final String traceType = fTrace.getResource().getPersistentProperty(TmfTraceElement.TRACETYPE);
 278             if (traceType == null)
 279                 return null;
 280             if (traceType.startsWith(CustomTxtTrace.class.getCanonicalName()))
 281                 return new CustomEventsTable(((CustomTxtTrace) fTrace).getDefinition(), parent, cacheSize);
 282             if (traceType.startsWith(CustomXmlTrace.class.getCanonicalName()))
 283                 return new CustomEventsTable(((CustomXmlTrace) fTrace).getDefinition(), parent, cacheSize);
 284             for (final IConfigurationElement ce : TmfTraceType.getTypeElements())
 285                 if (ce.getAttribute(TmfTraceType.ID_ATTR).equals(traceType)) {
 286                     final IConfigurationElement[] eventsTableTypeCE = ce.getChildren(TmfTraceType.EVENTS_TABLE_TYPE_ELEM);
 287                     if (eventsTableTypeCE.length != 1)
 288                         break;
 289                     final String eventsTableType = eventsTableTypeCE[0].getAttribute(TmfTraceType.CLASS_ATTR);
 290                     if ((eventsTableType == null) || (eventsTableType.length() == 0))
 291                         break;
 292                     final Bundle bundle = Platform.getBundle(ce.getContributor().getName());
 293                     final Class<?> c = bundle.loadClass(eventsTableType);
 294                     final Class<?>[] constructorArgs = new Class[] { Composite.class, int.class };
 295                     final Constructor<?> constructor = c.getConstructor(constructorArgs);
 296                     final Object[] args = new Object[] { parent, cacheSize };
 297                     eventsTable = (TmfEventsTable) constructor.newInstance(args);
 298                     break;
 299                 }
 300         } catch (final InvalidRegistryObjectException e) {
 301             e.printStackTrace();
 302         } catch (final CoreException e) {
 303             e.printStackTrace();
 304         } catch (final ClassNotFoundException e) {
 305             e.printStackTrace();
 306         } catch (final SecurityException e) {
 307             e.printStackTrace();
 308         } catch (final NoSuchMethodException e) {
 309             e.printStackTrace();
 310         } catch (final IllegalArgumentException e) {
 311             e.printStackTrace();
 312         } catch (final InstantiationException e) {
 313             e.printStackTrace();
 314         } catch (final IllegalAccessException e) {
 315             e.printStackTrace();
 316         } catch (final InvocationTargetException e) {
 317             e.printStackTrace();
 318         }
 319         return eventsTable;
 320     }
 321
 322     /**
 323      * Get the events table for an experiment.
 324      * If all traces in the experiment are of the same type,
 325      * use the extension point specified event table
 326      * @param experiment the experiment
 327      * @param parent the parent Composite
 328      * @param cacheSize the event table cache size
 329      * @return an events table of the appropriate type
 330      */
 331     private TmfEventsTable getExperimentEventsTable(final TmfExperiment<?> experiment, final Composite parent, final int cacheSize) {
 332         TmfEventsTable eventsTable = null;
 333         String commonTraceType = null;
 334         try {
 335             for (final ITmfTrace<?> trace : experiment.getTraces()) {
 336                 final IResource resource = trace.getResource();
 337                 if (resource == null)
 338                     return null;
 339                 final String traceType = resource.getPersistentProperty(TmfTraceElement.TRACETYPE);
 340                 if ((commonTraceType != null) && !commonTraceType.equals(traceType))
 341                     return null;
 342                 commonTraceType = traceType;
 343             }
 344             if (commonTraceType == null)
 345                 return null;
 346             if (commonTraceType.startsWith(CustomTxtTrace.class.getCanonicalName()))
 347                 return new CustomEventsTable(((CustomTxtTrace) experiment.getTraces()[0]).getDefinition(), parent, cacheSize);
 348             if (commonTraceType.startsWith(CustomXmlTrace.class.getCanonicalName()))
 349                 return new CustomEventsTable(((CustomXmlTrace) experiment.getTraces()[0]).getDefinition(), parent, cacheSize);
 350             for (final IConfigurationElement ce : TmfTraceType.getTypeElements())
 351                 if (ce.getAttribute(TmfTraceType.ID_ATTR).equals(commonTraceType)) {
 352                     final IConfigurationElement[] eventsTableTypeCE = ce.getChildren(TmfTraceType.EVENTS_TABLE_TYPE_ELEM);
 353                     if (eventsTableTypeCE.length != 1)
 354                         break;
 355                     final String eventsTableType = eventsTableTypeCE[0].getAttribute(TmfTraceType.CLASS_ATTR);
 356                     if ((eventsTableType == null) || (eventsTableType.length() == 0))
 357                         break;
 358                     final Bundle bundle = Platform.getBundle(ce.getContributor().getName());
 359                     final Class<?> c = bundle.loadClass(eventsTableType);
 360                     final Class<?>[] constructorArgs = new Class[] { Composite.class, int.class };
 361                     final Constructor<?> constructor = c.getConstructor(constructorArgs);
 362                     final Object[] args = new Object[] { parent, cacheSize };
 363                     eventsTable = (TmfEventsTable) constructor.newInstance(args);
 364                     break;
 365                 }
 366         } catch (final CoreException e) {
 367             e.printStackTrace();
 368         } catch (final InvalidRegistryObjectException e) {
 369             e.printStackTrace();
 370         } catch (final SecurityException e) {
 371             e.printStackTrace();
 372         } catch (final IllegalArgumentException e) {
 373             e.printStackTrace();
 374         } catch (final ClassNotFoundException e) {
 375             e.printStackTrace();
 376         } catch (final NoSuchMethodException e) {
 377             e.printStackTrace();
 378         } catch (final InstantiationException e) {
 379             e.printStackTrace();
 380         } catch (final IllegalAccessException e) {
 381             e.printStackTrace();
 382         } catch (final InvocationTargetException e) {
 383             e.printStackTrace();
 384         }
 385         return eventsTable;
 386     }
 387
 388     @Override
 389     public ITmfTrace<?> getTrace() {
 390         return fTrace;
 391     }
 392
 393     @Override
 394     public IFile getBookmarksFile() {
 395         return fFile;
 396     }
 397
 398     @Override
 399     public void setFocus() {
 400         fEventsTable.setFocus();
 401         if (fTrace != null)
 402             broadcast(new TmfTraceSelectedSignal(this, fTrace));
 403     }
 404
 405     @Override
 406     @SuppressWarnings("rawtypes")
 407     public Object getAdapter(final Class adapter) {
 408         if (IGotoMarker.class.equals(adapter))
 409             return fEventsTable;
 410         return super.getAdapter(adapter);
 411     }
 412
 413     @Override
 414     public void resourceChanged(final IResourceChangeEvent event) {
 415         for (final IMarkerDelta delta : event.findMarkerDeltas(IMarker.BOOKMARK, false))
 416             if (delta.getResource().equals(fFile))
 417                 if (delta.getKind() == IResourceDelta.REMOVED) {
 418                     final IMarker bookmark = delta.getMarker();
 419                     Display.getDefault().asyncExec(new Runnable() {
 420                         @Override
 421                         public void run() {
 422                             fEventsTable.removeBookmark(bookmark);
 423                         }
 424                     });
 425                 } else if (delta.getKind() == IResourceDelta.CHANGED)
 426                     Display.getDefault().asyncExec(new Runnable() {
 427                         @Override
 428                         public void run() {
 429                             fEventsTable.getTable().refresh();
 430                         }
 431                     });
 432     }
 433
 434     // ------------------------------------------------------------------------
 435     // Global commands
 436     // ------------------------------------------------------------------------
 437
 438     public void addBookmark() {
 439         fEventsTable.addBookmark(fFile);
 440     }
 441
 442
 443     // ------------------------------------------------------------------------
 444     // Signal handlers
 445     // ------------------------------------------------------------------------
 446
 447     @SuppressWarnings("unchecked")
 448     @TmfSignalHandler
 449     public void traceParserUpdated(final TmfTraceParserUpdatedSignal signal) {
 450         if (signal.getTraceResource().equals(fFile)) {
 451             broadcast(new TmfTraceClosedSignal(this, fTrace));
 452             try {
 453                 fTrace.getName();
 454                 fTrace = null;
 455                 final String traceTypeId = fFile.getPersistentProperty(TmfTraceElement.TRACETYPE);
 456                 if (traceTypeId != null)
 457                     for (final IConfigurationElement ce : TmfTraceType.getTypeElements())
 458                         if (traceTypeId.equals(ce.getAttribute(TmfTraceType.ID_ATTR))) {
 459                             fTrace = (ITmfTrace<?>) ce.createExecutableExtension(TmfTraceType.TRACE_TYPE_ATTR);
 460                             final ITmfEvent event = (TmfEvent) ce.createExecutableExtension(TmfTraceType.EVENT_TYPE_ATTR);
 461                             final String path = fFile.getLocationURI().getPath();
 462                             fTrace.initTrace(null, path, event.getClass());
 463                             break;
 464                         }
 465             } catch (final InvalidRegistryObjectException e) {
 466                 e.printStackTrace();
 467             } catch (final FileNotFoundException e) {
 468                 e.printStackTrace();
 469             } catch (final CoreException e) {
 470                 e.printStackTrace();
 471             }
 472             fEventsTable.dispose();
 473             if (fTrace != null) {
 474                 fEventsTable = createEventsTable(fParent, fTrace.getCacheSize());
 475                 fEventsTable.setTrace(fTrace, true);
 476                 broadcast(new TmfTraceOpenedSignal(this, fTrace, fFile, fEventsTable));
 477             } else
 478                 fEventsTable = new TmfEventsTable(fParent, 0);
 479             fParent.layout();
 480         }
 481     }
 482
 483     @TmfSignalHandler
 484     public void traceSelected(final TmfTraceSelectedSignal signal) {
 485         if ((signal.getSource() != this) && signal.getTrace().equals(fTrace))
 486             getSite().getPage().bringToTop(this);
 487     }
 488
 489 }