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
  19 import org.eclipse.core.resources.IMarker;
  20 import org.eclipse.core.resources.IMarkerDelta;
  21 import org.eclipse.core.resources.IResource;
  22 import org.eclipse.core.resources.IResourceChangeEvent;
  23 import org.eclipse.core.resources.IResourceChangeListener;
  24 import org.eclipse.core.resources.IResourceDelta;
  25 import org.eclipse.core.resources.ResourcesPlugin;
  26 import org.eclipse.core.runtime.CoreException;
  27 import org.eclipse.core.runtime.IConfigurationElement;
  28 import org.eclipse.core.runtime.IProgressMonitor;
  29 import org.eclipse.core.runtime.InvalidRegistryObjectException;
  30 import org.eclipse.core.runtime.Platform;
  31 import org.eclipse.linuxtools.tmf.core.event.TmfEvent;
  32 import org.eclipse.linuxtools.tmf.core.signal.TmfSignalHandler;
  33 import org.eclipse.linuxtools.tmf.core.signal.TmfTraceSelectedSignal;
  34 import org.eclipse.linuxtools.tmf.core.trace.ITmfTrace;
  35 import org.eclipse.linuxtools.tmf.core.util.TmfTraceType;
  36 import org.eclipse.linuxtools.tmf.ui.parsers.custom.CustomEventsTable;
  37 import org.eclipse.linuxtools.tmf.ui.parsers.custom.CustomTxtTrace;
  38 import org.eclipse.linuxtools.tmf.ui.parsers.custom.CustomXmlTrace;
  39 import org.eclipse.linuxtools.tmf.ui.project.model.TmfTraceElement;
  40 import org.eclipse.linuxtools.tmf.ui.signal.TmfTraceClosedSignal;
  41 import org.eclipse.linuxtools.tmf.ui.signal.TmfTraceOpenedSignal;
  42 import org.eclipse.linuxtools.tmf.ui.signal.TmfTraceParserUpdatedSignal;
  43 import org.eclipse.linuxtools.tmf.ui.viewers.events.TmfEventsTable;
  44 import org.eclipse.swt.widgets.Composite;
  45 import org.eclipse.swt.widgets.Display;
  46 import org.eclipse.ui.IEditorInput;
  47 import org.eclipse.ui.IEditorPart;
  48 import org.eclipse.ui.IEditorSite;
  49 import org.eclipse.ui.IFileEditorInput;
  50 import org.eclipse.ui.IPropertyListener;
  51 import org.eclipse.ui.IReusableEditor;
  52 import org.eclipse.ui.PartInitException;
  53 import org.eclipse.ui.ide.IGotoMarker;
  54 import org.osgi.framework.Bundle;
  55
  56 /**
  57  * <b><u>TmfEventsEditor</u></b>
  58  */
  59 public class TmfEventsEditor extends TmfEditor implements ITmfTraceEditor, IReusableEditor, IPropertyListener, IResourceChangeListener {
  60
  61     public static final String ID = "org.eclipse.linuxtools.tmf.ui.editors.events"; //$NON-NLS-1$
  62
  63     private TmfEventsTable fEventsTable;
  64     private IResource fResource;
  65     @SuppressWarnings("rawtypes")
  66     private ITmfTrace fTrace;
  67     private Composite fParent;
  68
  69     @Override
  70     public void doSave(IProgressMonitor monitor) {
  71     }
  72
  73     @Override
  74     public void doSaveAs() {
  75     }
  76
  77     @SuppressWarnings("unchecked")
  78     @Override
  79     public void init(IEditorSite site, IEditorInput input) throws PartInitException {
  80         if (input instanceof TmfEditorInput) {
  81             fResource = ((TmfEditorInput) input).getResource();
  82             fTrace = ((TmfEditorInput) input).getTrace();
  83         } else if (input instanceof IFileEditorInput) {
  84             fResource = ((IFileEditorInput) input).getFile();
  85             try {
  86                 String traceTypeId = fResource.getPersistentProperty(TmfTraceElement.TRACETYPE);
  87                 if (traceTypeId != null) {
  88                     for (IConfigurationElement ce : TmfTraceType.getTypeElements()) {
  89                         if (traceTypeId.equals(ce.getAttribute(TmfTraceType.ID_ATTR))) {
  90                             fTrace = (ITmfTrace<?>) ce.createExecutableExtension(TmfTraceType.TRACE_TYPE_ATTR);
  91                             TmfEvent event = (TmfEvent) ce.createExecutableExtension(TmfTraceType.EVENT_TYPE_ATTR);
  92                             String path = fResource.getLocationURI().getPath();
  93                             fTrace.initTrace(path, event.getClass(), true);
  94                             break;
  95                         }
  96                     }
  97                 }
  98             } catch (InvalidRegistryObjectException e) {
  99                 e.printStackTrace();
 100             } catch (FileNotFoundException e) {
 101                 e.printStackTrace();
 102             } catch (CoreException e) {
 103                 e.printStackTrace();
 104             }
 105             input = new TmfEditorInput(fResource, fTrace);
 106         } else {
 107             throw new PartInitException("Invalid IEditorInput: " + input.getClass()); //$NON-NLS-1$
 108         }
 109         if (fTrace == null) {
 110             throw new PartInitException("Invalid IEditorInput: " + fResource.getName()); //$NON-NLS-1$
 111         }
 112         super.setSite(site);
 113         super.setInput(input);
 114     }
 115
 116     @Override
 117     public boolean isDirty() {
 118         return false;
 119     }
 120
 121     @Override
 122     public boolean isSaveAsAllowed() {
 123         return false;
 124     }
 125
 126     @Override
 127     public void setInput(IEditorInput input) {
 128         super.setInput(input);
 129         firePropertyChange(IEditorPart.PROP_INPUT);
 130     }
 131
 132     @Override
 133         public void propertyChanged(Object source, int propId) {
 134         if (propId == IEditorPart.PROP_INPUT) {
 135             broadcast(new TmfTraceClosedSignal(this, fTrace));
 136             fResource = ((TmfEditorInput) getEditorInput()).getResource();
 137             fTrace = ((TmfEditorInput) getEditorInput()).getTrace();
 138             fEventsTable.dispose();
 139             if (fTrace != null) {
 140                 fEventsTable = createEventsTable(fParent, fTrace.getCacheSize());
 141                 fEventsTable.setTrace(fTrace, true);
 142                 fEventsTable.refreshBookmarks(fResource);
 143                 broadcast(new TmfTraceOpenedSignal(this, fTrace, fResource, fEventsTable));
 144             } else {
 145                 fEventsTable = new TmfEventsTable(fParent, 0);
 146             }
 147             fParent.layout();
 148         }
 149     }
 150
 151     @Override
 152     public void createPartControl(Composite parent) {
 153         fParent = parent;
 154         setPartName(getEditorInput().getName());
 155         if (fTrace != null) {
 156             fEventsTable = createEventsTable(parent, fTrace.getCacheSize());
 157             fEventsTable.setTrace(fTrace, true);
 158             fEventsTable.refreshBookmarks(fResource);
 159             broadcast(new TmfTraceOpenedSignal(this, fTrace, fResource, fEventsTable));
 160         } else {
 161             fEventsTable = new TmfEventsTable(parent, 0);
 162         }
 163         addPropertyListener(this);
 164         ResourcesPlugin.getWorkspace().addResourceChangeListener(this, IResourceChangeEvent.POST_CHANGE);
 165     }
 166
 167     @Override
 168     public void dispose() {
 169         ResourcesPlugin.getWorkspace().removeResourceChangeListener(this);
 170         removePropertyListener(this);
 171         if (fTrace != null) {
 172             broadcast(new TmfTraceClosedSignal(this, fTrace));
 173         }
 174         if (fEventsTable != null) {
 175             fEventsTable.dispose();
 176         }
 177         super.dispose();
 178     }
 179
 180     protected TmfEventsTable createEventsTable(Composite parent, int cacheSize) {
 181         TmfEventsTable eventsTable = getEventsTable(parent, cacheSize);
 182         if (eventsTable == null) {
 183             eventsTable = new TmfEventsTable(parent, cacheSize);
 184         }
 185         return eventsTable;
 186     }
 187
 188     private TmfEventsTable getEventsTable(Composite parent, int cacheSize) {
 189         TmfEventsTable eventsTable = null;
 190         try {
 191             String traceType = fResource.getPersistentProperty(TmfTraceElement.TRACETYPE);
 192             if (traceType.startsWith(CustomTxtTrace.class.getCanonicalName())) {
 193                 return new CustomEventsTable(((CustomTxtTrace) fTrace).getDefinition(), parent, cacheSize);
 194             }
 195             if (traceType.startsWith(CustomXmlTrace.class.getCanonicalName())) {
 196                 return new CustomEventsTable(((CustomXmlTrace) fTrace).getDefinition(), parent, cacheSize);
 197             }
 198             for (IConfigurationElement ce : TmfTraceType.getTypeElements()) {
 199                 if (ce.getAttribute(TmfTraceType.ID_ATTR).equals(traceType)) {
 200                     IConfigurationElement[] eventsTableTypeCE = ce.getChildren(TmfTraceType.EVENTS_TABLE_TYPE_ELEM);
 201                     if (eventsTableTypeCE.length != 1) {
 202                         break;
 203                     }
 204                     String eventsTableType = eventsTableTypeCE[0].getAttribute(TmfTraceType.CLASS_ATTR);
 205                     if (eventsTableType == null || eventsTableType.length() == 0) {
 206                         break;
 207                     }
 208                     Bundle bundle = Platform.getBundle(ce.getContributor().getName());
 209                     Class<?> c = bundle.loadClass(eventsTableType);
 210                     Class<?>[] constructorArgs = new Class[] { Composite.class, int.class };
 211                     Constructor<?> constructor = c.getConstructor(constructorArgs);
 212                     Object[] args = new Object[] { parent, cacheSize };
 213                     eventsTable = (TmfEventsTable) constructor.newInstance(args);
 214                     break;
 215                 }
 216             }
 217         } catch (InvalidRegistryObjectException e) {
 218             e.printStackTrace();
 219         } catch (CoreException e) {
 220             e.printStackTrace();
 221         } catch (ClassNotFoundException e) {
 222             e.printStackTrace();
 223         } catch (SecurityException e) {
 224             e.printStackTrace();
 225         } catch (NoSuchMethodException e) {
 226             e.printStackTrace();
 227         } catch (IllegalArgumentException e) {
 228             e.printStackTrace();
 229         } catch (InstantiationException e) {
 230             e.printStackTrace();
 231         } catch (IllegalAccessException e) {
 232             e.printStackTrace();
 233         } catch (InvocationTargetException e) {
 234             e.printStackTrace();
 235         }
 236         return eventsTable;
 237     }
 238
 239     @Override
 240         public ITmfTrace<?> getTrace() {
 241         return fTrace;
 242     }
 243
 244     @Override
 245     public IResource getResource() {
 246         return fResource;
 247     }
 248
 249     @Override
 250     public void setFocus() {
 251         fEventsTable.setFocus();
 252         if (fTrace != null) {
 253             broadcast(new TmfTraceSelectedSignal(this, fTrace));
 254         }
 255     }
 256
 257     @Override
 258     @SuppressWarnings("rawtypes")
 259     public Object getAdapter(Class adapter) {
 260         if (IGotoMarker.class.equals(adapter)) {
 261                 return fEventsTable;
 262         }
 263         return super.getAdapter(adapter);
 264     }
 265
 266     @Override
 267     public void resourceChanged(IResourceChangeEvent event) {
 268         for (IMarkerDelta delta : event.findMarkerDeltas(IMarker.BOOKMARK, false)) {
 269                 if (delta.getResource().equals(fResource) && delta.getKind() == IResourceDelta.REMOVED) {
 270                         final IMarker bookmark = delta.getMarker();
 271                         Display.getDefault().asyncExec(new Runnable() {
 272                                 @Override
 273                                 public void run() {
 274                                         fEventsTable.removeBookmark(bookmark);
 275                                 }
 276                         });
 277                 }
 278         }
 279     }
 280
 281     // ------------------------------------------------------------------------
 282     // Global commands
 283     // ------------------------------------------------------------------------
 284
 285     public void addBookmark() {
 286         fEventsTable.addBookmark(fResource);
 287     }
 288
 289
 290     // ------------------------------------------------------------------------
 291     // Signal handlers
 292     // ------------------------------------------------------------------------
 293
 294     @SuppressWarnings("unchecked")
 295     @TmfSignalHandler
 296     public void traceParserUpdated(TmfTraceParserUpdatedSignal signal) {
 297         if (signal.getTraceResource().equals(fResource)) {
 298             broadcast(new TmfTraceClosedSignal(this, fTrace));
 299             try {
 300                 fTrace = null;
 301                 String traceTypeId = fResource.getPersistentProperty(TmfTraceElement.TRACETYPE);
 302                 if (traceTypeId != null) {
 303                     for (IConfigurationElement ce : TmfTraceType.getTypeElements()) {
 304                         if (traceTypeId.equals(ce.getAttribute(TmfTraceType.ID_ATTR))) {
 305                             fTrace = (ITmfTrace<?>) ce.createExecutableExtension(TmfTraceType.TRACE_TYPE_ATTR);
 306                             TmfEvent event = (TmfEvent) ce.createExecutableExtension(TmfTraceType.EVENT_TYPE_ATTR);
 307                             String path = fResource.getLocationURI().getPath();
 308                             fTrace.initTrace(path, event.getClass(), true);
 309                             break;
 310                         }
 311                     }
 312                 }
 313             } catch (InvalidRegistryObjectException e) {
 314                 e.printStackTrace();
 315             } catch (FileNotFoundException e) {
 316                 e.printStackTrace();
 317             } catch (CoreException e) {
 318                 e.printStackTrace();
 319             }
 320             fEventsTable.dispose();
 321             if (fTrace != null) {
 322                 fEventsTable = createEventsTable(fParent, fTrace.getCacheSize());
 323                 fEventsTable.setTrace(fTrace, true);
 324                 broadcast(new TmfTraceOpenedSignal(this, fTrace, fResource, fEventsTable));
 325             } else {
 326                 fEventsTable = new TmfEventsTable(fParent, 0);
 327             }
 328             fParent.layout();
 329         }
 330     }
 331
 332     @TmfSignalHandler
 333     public void traceSelected(TmfTraceSelectedSignal signal) {
 334         if (signal.getSource() != this && signal.getTrace().equals(fTrace)) {
 335             getSite().getPage().bringToTop(this);
 336         }
 337     }
 338
 339 }