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