org.eclipse.linuxtools.tmf.ui/src/org/eclipse/linuxtools/tmf/ui/project/model/TmfOpenTraceHelper.java

   1 /**********************************************************************
   2  * Copyright (c) 2013 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  *   Matthew Khouzam - Initial API and implementation
  11  **********************************************************************/
  12
  13 package org.eclipse.linuxtools.tmf.ui.project.model;
  14
  15 import java.io.File;
  16 import java.util.List;
  17
  18 import org.eclipse.core.resources.IFile;
  19 import org.eclipse.core.resources.IFolder;
  20 import org.eclipse.core.resources.IProject;
  21 import org.eclipse.core.resources.IResource;
  22 import org.eclipse.core.resources.IWorkspace;
  23 import org.eclipse.core.resources.IWorkspaceRoot;
  24 import org.eclipse.core.resources.ResourcesPlugin;
  25 import org.eclipse.core.runtime.CoreException;
  26 import org.eclipse.core.runtime.IPath;
  27 import org.eclipse.core.runtime.IStatus;
  28 import org.eclipse.core.runtime.Path;
  29 import org.eclipse.core.runtime.Status;
  30 import org.eclipse.linuxtools.internal.tmf.ui.Activator;
  31 import org.eclipse.linuxtools.internal.tmf.ui.project.model.TmfImportHelper;
  32 import org.eclipse.linuxtools.internal.tmf.ui.project.model.TmfTraceImportException;
  33 import org.eclipse.linuxtools.tmf.core.event.ITmfEvent;
  34 import org.eclipse.linuxtools.tmf.core.exceptions.TmfTraceException;
  35 import org.eclipse.linuxtools.tmf.core.trace.ITmfTrace;
  36 import org.eclipse.linuxtools.tmf.ui.editors.TmfEditorInput;
  37 import org.eclipse.linuxtools.tmf.ui.editors.TmfEventsEditor;
  38 import org.eclipse.swt.widgets.Display;
  39 import org.eclipse.swt.widgets.MessageBox;
  40 import org.eclipse.swt.widgets.Shell;
  41 import org.eclipse.ui.IEditorInput;
  42 import org.eclipse.ui.IEditorPart;
  43 import org.eclipse.ui.IReusableEditor;
  44 import org.eclipse.ui.IWorkbench;
  45 import org.eclipse.ui.IWorkbenchPage;
  46 import org.eclipse.ui.PartInitException;
  47 import org.eclipse.ui.PlatformUI;
  48 import org.eclipse.ui.ide.IDE;
  49 import org.eclipse.ui.part.FileEditorInput;
  50
  51 /**
  52  * Open trace helper
  53  *
  54  * Helper class for opening trace resources and loading them to a tracing
  55  * project.
  56  *
  57  * @author Matthew Khouzam
  58  * @since 2.1
  59  */
  60 public class TmfOpenTraceHelper {
  61
  62     private static final String ENDL = System.getProperty("line.separator"); //$NON-NLS-1$
  63
  64     /**
  65      * Opens a trace from a path while importing it to the project
  66      * "projectRoot". The trace is linked as a resource.
  67      *
  68      * @param projectRoot
  69      *            The project to import to
  70      * @param path
  71      *            the file to import
  72      * @param shell
  73      *            the shell to use for dialogs
  74      * @return IStatus OK if successful
  75      * @throws CoreException
  76      *             core exceptions if something is not well set up in the back
  77      *             end
  78      */
  79     public IStatus openTraceFromPath(String projectRoot, String path, Shell shell) throws CoreException {
  80         TmfTraceType tt = TmfTraceType.getInstance();
  81         TraceTypeHelper traceTypeToSet = null;
  82         try {
  83             traceTypeToSet = tt.selectTraceType(path, shell);
  84         } catch (TmfTraceImportException e) {
  85             MessageBox mb = new MessageBox(shell);
  86             mb.setMessage(e.getMessage());
  87             mb.open();
  88             return new Status(IStatus.ERROR, Activator.PLUGIN_ID, e.getMessage());
  89         }
  90         if (traceTypeToSet == null) {
  91             return Status.CANCEL_STATUS;
  92         }
  93         IProject project = ResourcesPlugin.getWorkspace().getRoot().getProject(projectRoot);
  94         IFolder folder = project.getFolder(TmfTraceFolder.TRACE_FOLDER_NAME);
  95         String traceName = getTraceName(path, folder);
  96         if (traceExists(path, folder)) {
  97             return openTraceFromProject(projectRoot, traceName);
  98         }
  99         final IPath tracePath = folder.getFullPath().append(traceName);
 100         final IPath pathString = Path.fromOSString(path);
 101         IResource linkedTrace = TmfImportHelper.createLink(folder, pathString, traceName);
 102         if (linkedTrace != null && linkedTrace.exists()) {
 103             IStatus ret = TmfTraceType.setTraceType(tracePath, traceTypeToSet);
 104             if (ret.isOK()) {
 105                 ret = openTraceFromProject(projectRoot, traceName);
 106             }
 107             return ret;
 108         }
 109         return new Status(IStatus.ERROR, Activator.PLUGIN_ID,
 110                 Messages.TmfOpenTraceHelper_LinkFailed);
 111     }
 112
 113     private static boolean traceExists(String file, IFolder folder) {
 114         String val = getTraceName(file, folder);
 115         return (folder.findMember(val) != null);
 116     }
 117
 118     private static boolean isWrongMember(IFolder folder, String ret, final File traceFile) {
 119         final IResource candidate = folder.findMember(ret);
 120         if (candidate != null) {
 121             final IPath rawLocation = candidate.getRawLocation();
 122             final File file = rawLocation.toFile();
 123             return !file.equals(traceFile);
 124         }
 125         return false;
 126     }
 127
 128     /**
 129      * Gets the display name, either "filename" or "filename(n)" if there is
 130      * already a filename existing where n is the next non-used integer starting
 131      * from 2
 132      *
 133      * @param file
 134      *            the file with path
 135      * @param folder
 136      *            the folder to import to
 137      * @return the filename
 138      */
 139     private static String getTraceName(String file, IFolder folder) {
 140         String ret;
 141         final File traceFile = new File(file);
 142         ret = traceFile.getName();
 143         for (int i = 2; isWrongMember(folder, ret, traceFile); i++) {
 144             ret = traceFile.getName() + '(' + i + ')';
 145         }
 146         return ret;
 147     }
 148
 149     /**
 150      * Open a trace from a project
 151      *
 152      * @param projectRoot
 153      *            the root of the project
 154      * @param traceName
 155      *            the trace name
 156      * @return success or error
 157      */
 158     public static IStatus openTraceFromProject(String projectRoot, String traceName) {
 159         final IWorkspace workspace = ResourcesPlugin.getWorkspace();
 160         final IWorkspaceRoot root = workspace.getRoot();
 161         IProject project = root.getProject(projectRoot);
 162         TmfImportHelper.forceFolderRefresh(project.getFolder(TmfTraceFolder.TRACE_FOLDER_NAME));
 163
 164         final TmfProjectElement project2 = TmfProjectRegistry.getProject(project, true);
 165         final TmfTraceFolder tracesFolder = project2.getTracesFolder();
 166         final List<TmfTraceElement> traces = tracesFolder.getTraces();
 167         TmfTraceElement found = null;
 168         for (TmfTraceElement candidate : traces) {
 169             if (candidate.getName().equals(traceName)) {
 170                 found = candidate;
 171             }
 172         }
 173         if (found == null) {
 174             return new Status(IStatus.ERROR, Activator.PLUGIN_ID, Messages.TmfOpenTraceHelper_ErrorOpeningTrace);
 175         }
 176         return openTraceFromElement(found);
 177     }
 178
 179     /**
 180      * Open a trace from a TmfTraceElement
 181      *
 182      * @param traceElement
 183      *            the {@link TmfTraceElement} to open
 184      * @return Status.OK_STATUS
 185      */
 186     public static IStatus openTraceFromElement(final TmfTraceElement traceElement) {
 187         Thread thread = new Thread() {
 188             @Override
 189             public void run() {
 190
 191                 final ITmfTrace trace = traceElement.instantiateTrace();
 192                 final ITmfEvent traceEvent = traceElement.instantiateEvent();
 193                 if ((trace == null) || (traceEvent == null)) {
 194                     if (trace != null) {
 195                         TraceUtils.displayErrorMsg(Messages.TmfOpenTraceHelper_OpenTrace, Messages.TmfOpenTraceHelper_NoTraceType);
 196                         trace.dispose();
 197                     }
 198                     return;
 199                 }
 200
 201                 // Get the editor_id from the extension point
 202                 String traceEditorId = traceElement.getEditorId();
 203                 final String editorId = (traceEditorId != null) ? traceEditorId : TmfEventsEditor.ID;
 204                 try {
 205                     trace.initTrace(traceElement.getResource(), traceElement.getLocation().getPath(), traceEvent.getClass());
 206                 } catch (final TmfTraceException e) {
 207                     TraceUtils.displayErrorMsg(Messages.TmfOpenTraceHelper_OpenTrace, Messages.TmfOpenTraceHelper_InitError + ENDL + ENDL + e);
 208                     trace.dispose();
 209                     return;
 210                 }
 211
 212                 final IFile file;
 213                 try {
 214                     file = traceElement.createBookmarksFile();
 215                 } catch (final CoreException e) {
 216                     Activator.getDefault().logError(Messages.TmfOpenTraceHelper_ErrorOpeningTrace + traceElement.getName());
 217                     TraceUtils.displayErrorMsg(Messages.TmfOpenTraceHelper_OpenTrace, Messages.TmfOpenTraceHelper_Error + ENDL + ENDL + e.getMessage());
 218                     trace.dispose();
 219                     return;
 220                 }
 221
 222                 Display.getDefault().asyncExec(new Runnable() {
 223                     @Override
 224                     public void run() {
 225                         try {
 226                             final IEditorInput editorInput = new TmfEditorInput(file, trace);
 227                             final IWorkbench wb = PlatformUI.getWorkbench();
 228                             final IWorkbenchPage activePage = wb.getActiveWorkbenchWindow().getActivePage();
 229                             final IEditorPart editor = activePage.findEditor(new FileEditorInput(file));
 230                             if ((editor != null) && (editor instanceof IReusableEditor)) {
 231                                 activePage.reuseEditor((IReusableEditor) editor, editorInput);
 232                                 activePage.activate(editor);
 233                             } else {
 234                                 activePage.openEditor(editorInput, editorId);
 235                                 IDE.setDefaultEditor(file, editorId);
 236                                 // editor should dispose the trace on close
 237                             }
 238                         } catch (final PartInitException e) {
 239                             TraceUtils.displayErrorMsg(Messages.TmfOpenTraceHelper_OpenTrace, Messages.TmfOpenTraceHelper_ErrorOpeningTrace + ENDL + ENDL + e.getMessage());
 240                             Activator.getDefault().logError(Messages.TmfOpenTraceHelper_ErrorOpeningTrace + traceElement.getName());
 241                             trace.dispose();
 242                         }
 243                     }
 244                 });
 245             }
 246         };
 247         thread.start();
 248         return Status.OK_STATUS;
 249     }
 250
 251 }