projects / deliverable / tracecompass.git / blame
? search:
summary | shortlog | log | commit | commitdiff | tree
blob | blame (incremental) | history | HEAD
tmf: Move TmfTraceType and custom parsers to tmf.core
[deliverable/tracecompass.git] / org.eclipse.linuxtools.tmf.ui / src / org / eclipse / linuxtools / tmf / ui / project / model / TmfOpenTraceHelper.java
CommitLineData
76fccfb0
MK		 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
67c53011 11 * Patrick Tasse - Update open trace and add open experiment
76fccfb0
MK		 12 **********************************************************************/
13
14package org.eclipse.linuxtools.tmf.ui.project.model;
15
16import java.io.File;
17import java.util.List;
18
19import org.eclipse.core.resources.IFile;
20import org.eclipse.core.resources.IFolder;
21import org.eclipse.core.resources.IProject;
22import org.eclipse.core.resources.IResource;
23import org.eclipse.core.resources.IWorkspace;
24import org.eclipse.core.resources.IWorkspaceRoot;
25import org.eclipse.core.resources.ResourcesPlugin;
26import org.eclipse.core.runtime.CoreException;
27import org.eclipse.core.runtime.IPath;
28import org.eclipse.core.runtime.IStatus;
29import org.eclipse.core.runtime.Path;
30import org.eclipse.core.runtime.Status;
31import org.eclipse.linuxtools.internal.tmf.ui.Activator;
32import org.eclipse.linuxtools.internal.tmf.ui.project.model.TmfImportHelper;
76fccfb0
MK		 33import org.eclipse.linuxtools.tmf.core.event.ITmfEvent;
34import org.eclipse.linuxtools.tmf.core.exceptions.TmfTraceException;
47aafe74
AM		 35import org.eclipse.linuxtools.tmf.core.project.model.TmfTraceImportException;
36import org.eclipse.linuxtools.tmf.core.project.model.TraceTypeHelper;
76fccfb0 37import org.eclipse.linuxtools.tmf.core.trace.ITmfTrace;
67c53011 38import org.eclipse.linuxtools.tmf.core.trace.TmfExperiment;
76fccfb0
MK		 39import org.eclipse.linuxtools.tmf.ui.editors.TmfEditorInput;
40import org.eclipse.linuxtools.tmf.ui.editors.TmfEventsEditor;
41import org.eclipse.swt.widgets.Display;
42import org.eclipse.swt.widgets.MessageBox;
43import org.eclipse.swt.widgets.Shell;
44import org.eclipse.ui.IEditorInput;
45import org.eclipse.ui.IEditorPart;
371536f0 46import org.eclipse.ui.IEditorReference;
eb271b88 47import org.eclipse.ui.IReusableEditor;
76fccfb0
MK		 48import org.eclipse.ui.IWorkbench;
49import org.eclipse.ui.IWorkbenchPage;
50import org.eclipse.ui.PartInitException;
51import org.eclipse.ui.PlatformUI;
52import org.eclipse.ui.ide.IDE;
53import org.eclipse.ui.part.FileEditorInput;
54
55/**
56 * Open trace helper
57 *
58 * Helper class for opening trace resources and loading them to a tracing
59 * project.
60 *
61 * @author Matthew Khouzam
62 * @since 2.1
63 */
64public class TmfOpenTraceHelper {
65
66 private static final String ENDL = System.getProperty("line.separator"); //$NON-NLS-1$
67
68 /**
69 * Opens a trace from a path while importing it to the project
70 * "projectRoot". The trace is linked as a resource.
71 *
72 * @param projectRoot
73 * The project to import to
74 * @param path
75 * the file to import
76 * @param shell
77 * the shell to use for dialogs
78 * @return IStatus OK if successful
79 * @throws CoreException
80 * core exceptions if something is not well set up in the back
81 * end
82 */
83 public IStatus openTraceFromPath(String projectRoot, String path, Shell shell) throws CoreException {
4958a213
MK		 84 return openTraceFromPath(projectRoot, path, shell, null);
85 }
86
87 /**
88 * Opens a trace from a path while importing it to the project
89 * "projectRoot". The trace is linked as a resource.
90 *
91 * @param projectRoot
92 * The project to import to
93 * @param path
94 * the file to import
95 * @param shell
96 * the shell to use for dialogs
97 * @param tracetypeHint
98 * The trace type id, can be null
99 * @return IStatus OK if successful
100 * @throws CoreException
101 * core exceptions if something is not well set up in the back
102 * end
103 *
104 * @since 2.2
105 */
106 public IStatus openTraceFromPath(String projectRoot, String path, Shell shell, String tracetypeHint) throws CoreException {
76fccfb0
MK		 107 TraceTypeHelper traceTypeToSet = null;
108 try {
47aafe74 109 traceTypeToSet = TmfTraceTypeUIUtils.selectTraceType(path, shell, tracetypeHint);
76fccfb0
MK		 110 } catch (TmfTraceImportException e) {
111 MessageBox mb = new MessageBox(shell);
112 mb.setMessage(e.getMessage());
113 mb.open();
114 return new Status(IStatus.ERROR, Activator.PLUGIN_ID, e.getMessage());
115 }
116 if (traceTypeToSet == null) {
117 return Status.CANCEL_STATUS;
118 }
119 IProject project = ResourcesPlugin.getWorkspace().getRoot().getProject(projectRoot);
120 IFolder folder = project.getFolder(TmfTraceFolder.TRACE_FOLDER_NAME);
121 String traceName = getTraceName(path, folder);
122 if (traceExists(path, folder)) {
123 return openTraceFromProject(projectRoot, traceName);
124 }
125 final IPath tracePath = folder.getFullPath().append(traceName);
126 final IPath pathString = Path.fromOSString(path);
127 IResource linkedTrace = TmfImportHelper.createLink(folder, pathString, traceName);
128 if (linkedTrace != null && linkedTrace.exists()) {
47aafe74 129 IStatus ret = TmfTraceTypeUIUtils.setTraceType(tracePath, traceTypeToSet);
76fccfb0
MK		 130 if (ret.isOK()) {
131 ret = openTraceFromProject(projectRoot, traceName);
132 }
133 return ret;
134 }
135 return new Status(IStatus.ERROR, Activator.PLUGIN_ID,
136 Messages.TmfOpenTraceHelper_LinkFailed);
137 }
138
139 private static boolean traceExists(String file, IFolder folder) {
140 String val = getTraceName(file, folder);
141 return (folder.findMember(val) != null);
142 }
143
144 private static boolean isWrongMember(IFolder folder, String ret, final File traceFile) {
145 final IResource candidate = folder.findMember(ret);
146 if (candidate != null) {
147 final IPath rawLocation = candidate.getRawLocation();
148 final File file = rawLocation.toFile();
149 return !file.equals(traceFile);
150 }
151 return false;
152 }
153
154 /**
155 * Gets the display name, either "filename" or "filename(n)" if there is
156 * already a filename existing where n is the next non-used integer starting
157 * from 2
158 *
159 * @param file
160 * the file with path
161 * @param folder
162 * the folder to import to
163 * @return the filename
164 */
165 private static String getTraceName(String file, IFolder folder) {
166 String ret;
167 final File traceFile = new File(file);
168 ret = traceFile.getName();
169 for (int i = 2; isWrongMember(folder, ret, traceFile); i++) {
170 ret = traceFile.getName() + '(' + i + ')';
171 }
172 return ret;
173 }
174
175 /**
176 * Open a trace from a project
177 *
178 * @param projectRoot
179 * the root of the project
180 * @param traceName
181 * the trace name
182 * @return success or error
183 */
184 public static IStatus openTraceFromProject(String projectRoot, String traceName) {
185 final IWorkspace workspace = ResourcesPlugin.getWorkspace();
186 final IWorkspaceRoot root = workspace.getRoot();
187 IProject project = root.getProject(projectRoot);
f537c959
PT		 188 final TmfProjectElement projectElement = TmfProjectRegistry.getProject(project, true);
189 final TmfTraceFolder tracesFolder = projectElement.getTracesFolder();
76fccfb0
MK		 190 final List<TmfTraceElement> traces = tracesFolder.getTraces();
191 TmfTraceElement found = null;
192 for (TmfTraceElement candidate : traces) {
193 if (candidate.getName().equals(traceName)) {
194 found = candidate;
195 }
196 }
197 if (found == null) {
198 return new Status(IStatus.ERROR, Activator.PLUGIN_ID, Messages.TmfOpenTraceHelper_ErrorOpeningTrace);
199 }
67c53011
PT		 200 openTraceFromElement(found);
201 return Status.OK_STATUS;
76fccfb0
MK		 202 }
203
204 /**
4958a213
MK		 205 * Open a trace from a trace element. If the trace is already opened, its
206 * editor is activated and brought to top.
76fccfb0
MK		 207 *
208 * @param traceElement
209 * the {@link TmfTraceElement} to open
76fccfb0 210 */
67c53011
PT		 211 public static void openTraceFromElement(final TmfTraceElement traceElement) {
212
213 final IFile file;
214 try {
215 file = traceElement.createBookmarksFile();
216 } catch (final CoreException e) {
217 Activator.getDefault().logError(Messages.TmfOpenTraceHelper_ErrorOpeningTrace + ' ' + traceElement.getName());
218 TraceUtils.displayErrorMsg(Messages.TmfOpenTraceHelper_OpenTrace, Messages.TmfOpenTraceHelper_ErrorTrace + ENDL + ENDL + e.getMessage());
219 return;
220 }
221
222 final IWorkbench wb = PlatformUI.getWorkbench();
223 final IWorkbenchPage activePage = wb.getActiveWorkbenchWindow().getActivePage();
371536f0 224 final IEditorPart editor = findEditor(new FileEditorInput(file), true);
67c53011
PT		 225 if (editor != null) {
226 activePage.activate(editor);
227 return;
228 }
229
76fccfb0
MK		 230 Thread thread = new Thread() {
231 @Override
232 public void run() {
233
234 final ITmfTrace trace = traceElement.instantiateTrace();
235 final ITmfEvent traceEvent = traceElement.instantiateEvent();
236 if ((trace == null) || (traceEvent == null)) {
67c53011 237 TraceUtils.displayErrorMsg(Messages.TmfOpenTraceHelper_OpenTrace, Messages.TmfOpenTraceHelper_NoTraceType);
76fccfb0 238 if (trace != null) {
76fccfb0
MK		 239 trace.dispose();
240 }
241 return;
242 }
243
76fccfb0
MK		 244 try {
245 trace.initTrace(traceElement.getResource(), traceElement.getLocation().getPath(), traceEvent.getClass());
246 } catch (final TmfTraceException e) {
247 TraceUtils.displayErrorMsg(Messages.TmfOpenTraceHelper_OpenTrace, Messages.TmfOpenTraceHelper_InitError + ENDL + ENDL + e);
248 trace.dispose();
249 return;
250 }
251
67c53011
PT		 252 // Get the editor id from the extension point
253 String traceEditorId = traceElement.getEditorId();
254 final String editorId = (traceEditorId != null) ? traceEditorId : TmfEventsEditor.ID;
255 final IEditorInput editorInput = new TmfEditorInput(file, trace);
76fccfb0
MK		 256
257 Display.getDefault().asyncExec(new Runnable() {
258 @Override
259 public void run() {
260 try {
67c53011
PT		 261 activePage.openEditor(editorInput, editorId);
262 IDE.setDefaultEditor(file, editorId);
263 // editor should dispose the trace on close
76fccfb0
MK		 264 } catch (final PartInitException e) {
265 TraceUtils.displayErrorMsg(Messages.TmfOpenTraceHelper_OpenTrace, Messages.TmfOpenTraceHelper_ErrorOpeningTrace + ENDL + ENDL + e.getMessage());
67c53011 266 Activator.getDefault().logError(Messages.TmfOpenTraceHelper_ErrorOpeningTrace + ' ' + traceElement.getName());
76fccfb0
MK		 267 trace.dispose();
268 }
269 }
270 });
271 }
272 };
273 thread.start();
67c53011
PT		 274 }
275
276 /**
4958a213
MK		 277 * Open an experiment from an experiment element. If the experiment is
278 * already opened, its editor is activated and brought to top.
67c53011
PT		 279 *
280 * @param experimentElement
281 * the {@link TmfExperimentElement} to open
282 */
283 public static void openExperimentFromElement(final TmfExperimentElement experimentElement) {
284
285 final IFile file;
286 try {
287 file = experimentElement.createBookmarksFile();
288 } catch (final CoreException e) {
289 Activator.getDefault().logError(Messages.TmfOpenTraceHelper_ErrorOpeningExperiment + ' ' + experimentElement.getName());
290 TraceUtils.displayErrorMsg(Messages.TmfOpenTraceHelper_OpenExperiment, Messages.TmfOpenTraceHelper_ErrorExperiment + ENDL + ENDL + e.getMessage());
291 return;
292 }
293
294 final IWorkbench wb = PlatformUI.getWorkbench();
295 final IWorkbenchPage activePage = wb.getActiveWorkbenchWindow().getActivePage();
371536f0 296 final IEditorPart editor = findEditor(new FileEditorInput(file), true);
67c53011
PT		 297 if (editor != null) {
298 activePage.activate(editor);
299 return;
300 }
301
302 Thread thread = new Thread() {
303 @Override
304 public void run() {
305
4958a213
MK		 306 /*
307 * Unlike traces, there is no instanceExperiment, so we call
308 * this function here alone. Maybe it would be better to do this
309 * on experiment's element constructor?
67c53011
PT		 310 */
311 experimentElement.refreshSupplementaryFolder();
312
313 // Instantiate the experiment's traces
314 final List<TmfTraceElement> traceEntries = experimentElement.getTraces();
315 final int nbTraces = traceEntries.size();
316 int cacheSize = Integer.MAX_VALUE;
317 String commonEditorId = null;
318 final ITmfTrace[] traces = new ITmfTrace[nbTraces];
319 for (int i = 0; i < nbTraces; i++) {
320 TmfTraceElement element = traceEntries.get(i);
321
4958a213
MK		 322 // Since trace is under an experiment, use the original
323 // trace from the traces folder
67c53011
PT		 324 element = element.getElementUnderTraceFolder();
325
326 final ITmfTrace trace = element.instantiateTrace();
327 final ITmfEvent traceEvent = element.instantiateEvent();
328 if ((trace == null) || (traceEvent == null)) {
eb271b88
PT		 329 TraceUtils.displayErrorMsg(Messages.TmfOpenTraceHelper_OpenExperiment,
330 Messages.TmfOpenTraceHelper_ErrorOpeningTrace + ' ' + element.getName() +
4958a213 331 ENDL + Messages.TmfOpenTraceHelper_NoTraceType);
67c53011
PT		 332 for (int j = 0; j < i; j++) {
333 traces[j].dispose();
334 }
335 if (trace != null) {
336 trace.dispose();
337 }
338 return;
339 }
340 try {
341 trace.initTrace(element.getResource(), element.getLocation().getPath(), traceEvent.getClass());
342 } catch (final TmfTraceException e) {
eb271b88
PT		 343 TraceUtils.displayErrorMsg(Messages.TmfOpenTraceHelper_OpenExperiment,
344 element.getName() + ':' + ' ' + Messages.TmfOpenTraceHelper_InitError + ENDL + ENDL + e);
67c53011
PT		 345 for (int j = 0; j < i; j++) {
346 traces[j].dispose();
347 }
348 trace.dispose();
349 return;
350 }
351 cacheSize = Math.min(cacheSize, trace.getCacheSize());
352
4958a213
MK		 353 // If all traces use the same editorId, use it, otherwise
354 // use the default
67c53011
PT		 355 final String editorId = element.getEditorId();
356 if (commonEditorId == null) {
357 commonEditorId = (editorId != null) ? editorId : TmfEventsEditor.ID;
358 } else if (!commonEditorId.equals(editorId)) {
359 commonEditorId = TmfEventsEditor.ID;
360 }
361 traces[i] = trace;
362 }
363
364 // Create the experiment
365 final TmfExperiment experiment = new TmfExperiment(ITmfEvent.class, experimentElement.getName(), traces, cacheSize, experimentElement.getResource());
366 experiment.setBookmarksFile(file);
367
368 final String editorId = commonEditorId;
369 final IEditorInput editorInput = new TmfEditorInput(file, experiment);
370
371 Display.getDefault().asyncExec(new Runnable() {
372 @Override
373 public void run() {
374 try {
375 activePage.openEditor(editorInput, editorId);
376 IDE.setDefaultEditor(file, editorId);
377 // editor should dispose the trace on close
378 } catch (final PartInitException e) {
379 TraceUtils.displayErrorMsg(Messages.TmfOpenTraceHelper_OpenExperiment, Messages.TmfOpenTraceHelper_ErrorOpeningExperiment + ENDL + ENDL + e.getMessage());
380 Activator.getDefault().logError(Messages.TmfOpenTraceHelper_ErrorOpeningExperiment + ' ' + experimentElement.getName());
381 experiment.dispose();
382 }
383 }
384 });
385 }
386 };
387 thread.start();
76fccfb0
MK		 388 }
389
371536f0 390 /**
4958a213
MK		 391 * Returns the editor with the specified input. Returns null if there is no
392 * opened editor with that input. If restore is requested, the method finds
393 * and returns the editor even if it is not restored yet after a restart.
394 *
395 * @param input
396 * the editor input
397 * @param restore
398 * true if the editor should be restored
399 * @return an editor with input equals to <code>input</code>
400 */
371536f0
PT		 401 private static IEditorPart findEditor(IEditorInput input, boolean restore) {
402 final IWorkbench wb = PlatformUI.getWorkbench();
403 final IWorkbenchPage activePage = wb.getActiveWorkbenchWindow().getActivePage();
404 for (IEditorReference editorReference : activePage.getEditorReferences()) {
405 try {
406 IEditorInput editorInput = editorReference.getEditorInput();
407 if (editorInput.equals(input)) {
408 return editorReference.getEditor(restore);
409 }
410 } catch (PartInitException e) {
411 }
412 }
413 return null;
4958a213 414 }
371536f0 415
eb271b88
PT		 416 /**
417 * Reopen a trace from a trace element in the provided editor
418 *
419 * @param traceElement
420 * the {@link TmfTraceElement} to open
421 * @param editor
422 * the reusable editor
423 */
424 public static void reopenTraceFromElement(final TmfTraceElement traceElement, final IReusableEditor editor) {
425
426 final IFile file;
427 try {
428 file = traceElement.createBookmarksFile();
429 } catch (final CoreException e) {
430 Activator.getDefault().logError(Messages.TmfOpenTraceHelper_ErrorOpeningTrace + ' ' + traceElement.getName());
431 TraceUtils.displayErrorMsg(Messages.TmfOpenTraceHelper_OpenTrace, Messages.TmfOpenTraceHelper_ErrorTrace + ENDL + ENDL + e.getMessage());
432 return;
433 }
434
435 Thread thread = new Thread() {
436 @Override
437 public void run() {
438
439 final ITmfTrace trace = traceElement.instantiateTrace();
440 final ITmfEvent traceEvent = traceElement.instantiateEvent();
441 if ((trace == null) || (traceEvent == null)) {
442 TraceUtils.displayErrorMsg(Messages.TmfOpenTraceHelper_OpenTrace, Messages.TmfOpenTraceHelper_NoTraceType);
443 if (trace != null) {
444 trace.dispose();
445 }
446 return;
447 }
448
449 try {
450 trace.initTrace(traceElement.getResource(), traceElement.getLocation().getPath(), traceEvent.getClass());
451 } catch (final TmfTraceException e) {
452 TraceUtils.displayErrorMsg(Messages.TmfOpenTraceHelper_OpenTrace, Messages.TmfOpenTraceHelper_InitError + ENDL + ENDL + e);
453 trace.dispose();
454 return;
455 }
456
457 final IEditorInput editorInput = new TmfEditorInput(file, trace);
458
459 Display.getDefault().asyncExec(new Runnable() {
460 @Override
461 public void run() {
462 final IWorkbench wb = PlatformUI.getWorkbench();
463 final IWorkbenchPage activePage = wb.getActiveWorkbenchWindow().getActivePage();
464 activePage.reuseEditor(editor, editorInput);
465 activePage.activate(editor);
466 }
467 });
468 }
469 };
470 thread.start();
471 }
472
473 /**
474 * Reopen an experiment from an experiment element in the provided editor
475 *
476 * @param experimentElement
477 * the {@link TmfExperimentElement} to open
478 * @param editor
479 * the reusable editor
480 */
481 public static void reopenExperimentFromElement(final TmfExperimentElement experimentElement, final IReusableEditor editor) {
482
483 final IFile file;
484 try {
485 file = experimentElement.createBookmarksFile();
486 } catch (final CoreException e) {
487 Activator.getDefault().logError(Messages.TmfOpenTraceHelper_ErrorOpeningExperiment + ' ' + experimentElement.getName());
488 TraceUtils.displayErrorMsg(Messages.TmfOpenTraceHelper_OpenExperiment, Messages.TmfOpenTraceHelper_ErrorExperiment + ENDL + ENDL + e.getMessage());
489 return;
490 }
491
492 Thread thread = new Thread() {
493 @Override
494 public void run() {
495
4958a213
MK		 496 /*
497 * Unlike traces, there is no instanceExperiment, so we call
498 * this function here alone. Maybe it would be better to do this
499 * on experiment's element constructor?
eb271b88
PT		 500 */
501 experimentElement.refreshSupplementaryFolder();
502
503 // Instantiate the experiment's traces
504 final List<TmfTraceElement> traceEntries = experimentElement.getTraces();
505 final int nbTraces = traceEntries.size();
506 int cacheSize = Integer.MAX_VALUE;
507 final ITmfTrace[] traces = new ITmfTrace[nbTraces];
508 for (int i = 0; i < nbTraces; i++) {
509 TmfTraceElement element = traceEntries.get(i);
510
4958a213
MK		 511 // Since trace is under an experiment, use the original
512 // trace from the traces folder
eb271b88
PT		 513 element = element.getElementUnderTraceFolder();
514
515 final ITmfTrace trace = element.instantiateTrace();
516 final ITmfEvent traceEvent = element.instantiateEvent();
517 if ((trace == null) || (traceEvent == null)) {
518 TraceUtils.displayErrorMsg(Messages.TmfOpenTraceHelper_OpenExperiment,
519 Messages.TmfOpenTraceHelper_ErrorOpeningTrace + ' ' + element.getName() +
4958a213 520 ENDL + Messages.TmfOpenTraceHelper_NoTraceType);
eb271b88
PT		 521 for (int j = 0; j < i; j++) {
522 traces[j].dispose();
523 }
524 if (trace != null) {
525 trace.dispose();
526 }
527 return;
528 }
529 try {
530 trace.initTrace(element.getResource(), element.getLocation().getPath(), traceEvent.getClass());
531 } catch (final TmfTraceException e) {
532 TraceUtils.displayErrorMsg(Messages.TmfOpenTraceHelper_OpenExperiment,
533 element.getName() + ':' + ' ' + Messages.TmfOpenTraceHelper_InitError + ENDL + ENDL + e);
534 for (int j = 0; j < i; j++) {
535 traces[j].dispose();
536 }
537 trace.dispose();
538 return;
539 }
540 cacheSize = Math.min(cacheSize, trace.getCacheSize());
541
542 traces[i] = trace;
543 }
544
545 // Create the experiment
546 final TmfExperiment experiment = new TmfExperiment(ITmfEvent.class, experimentElement.getName(), traces, cacheSize, experimentElement.getResource());
547 experiment.setBookmarksFile(file);
548
549 final IEditorInput editorInput = new TmfEditorInput(file, experiment);
550
551 Display.getDefault().asyncExec(new Runnable() {
552 @Override
553 public void run() {
554 final IWorkbench wb = PlatformUI.getWorkbench();
555 final IWorkbenchPage activePage = wb.getActiveWorkbenchWindow().getActivePage();
556 activePage.reuseEditor(editor, editorInput);
557 activePage.activate(editor);
558 }
559 });
560 }
561 };
562 thread.start();
563 }
564
76fccfb0 565}
Tracecompass - Deliverables
This page took 0.077819 seconds and 5 git commands to generate.