← Back to branch summary

~ubuntu-branches/ubuntu/trusty/eclipse-linuxtools/trusty

« back to all changes in this revision

Viewing changes to lttng/org.eclipse.linuxtools.tmf.ui/src/org/eclipse/linuxtools/internal/tmf/ui/project/handlers/OpenTraceHandler.java

  • Committer: Package Import Robot
  • Author(s): Jakub Adam
  • Date: 2012-06-29 12:07:30 UTC
  • Revision ID: package-import@ubuntu.com-20120629120730-bfri1xys1i71dpn6
Tags: upstream-1.0.0
Import upstream version 1.0.0

Show diffs side-by-side

added added

removed removed

Lines of Context:
lttng/org.eclipse.linuxtools.tmf.ui/src/org/eclipse/linuxtools/internal/tmf/ui/project/handlers/OpenTraceHandler.java
 
1
/*******************************************************************************
 
2
 * Copyright (c) 2009, 2010, 2011 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
 *   Francois Chouinard - Initial API and implementation
 
11
 *******************************************************************************/
 
12
 
 
13
package org.eclipse.linuxtools.internal.tmf.ui.project.handlers;
 
14
 
 
15
import java.io.ByteArrayInputStream;
 
16
import java.io.InputStream;
 
17
 
 
18
import org.eclipse.core.commands.AbstractHandler;
 
19
import org.eclipse.core.commands.ExecutionEvent;
 
20
import org.eclipse.core.commands.ExecutionException;
 
21
import org.eclipse.core.resources.IFile;
 
22
import org.eclipse.core.resources.IFolder;
 
23
import org.eclipse.core.resources.IResource;
 
24
import org.eclipse.core.runtime.CoreException;
 
25
import org.eclipse.jface.viewers.ISelection;
 
26
import org.eclipse.jface.viewers.ISelectionProvider;
 
27
import org.eclipse.jface.viewers.TreeSelection;
 
28
import org.eclipse.linuxtools.internal.tmf.ui.Activator;
 
29
import org.eclipse.linuxtools.tmf.core.TmfCommonConstants;
 
30
import org.eclipse.linuxtools.tmf.core.event.ITmfEvent;
 
31
import org.eclipse.linuxtools.tmf.core.exceptions.TmfTraceException;
 
32
import org.eclipse.linuxtools.tmf.core.signal.TmfExperimentSelectedSignal;
 
33
import org.eclipse.linuxtools.tmf.core.signal.TmfSignalManager;
 
34
import org.eclipse.linuxtools.tmf.core.trace.ITmfTrace;
 
35
import org.eclipse.linuxtools.tmf.core.trace.TmfExperiment;
 
36
import org.eclipse.linuxtools.tmf.core.trace.TmfTrace;
 
37
import org.eclipse.linuxtools.tmf.ui.editors.EventsViewEditor;
 
38
import org.eclipse.linuxtools.tmf.ui.editors.TmfEditorInput;
 
39
import org.eclipse.linuxtools.tmf.ui.project.model.TmfTraceElement;
 
40
import org.eclipse.swt.widgets.MessageBox;
 
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.IWorkbenchPart;
 
47
import org.eclipse.ui.IWorkbenchWindow;
 
48
import org.eclipse.ui.PartInitException;
 
49
import org.eclipse.ui.PlatformUI;
 
50
import org.eclipse.ui.ide.IDE;
 
51
import org.eclipse.ui.part.FileEditorInput;
 
52
 
 
53
/**
 
54
 * <b><u>OpenTraceHandler</u></b>
 
55
 * <p>
 
56
 * TODO: Add support for multiple trace selection
 
57
 */
 
58
public class OpenTraceHandler extends AbstractHandler {
 
59
 
 
60
    private static final String BOOKMARKS_HIDDEN_FILE = ".bookmarks"; //$NON-NLS-1$
 
61
 
 
62
    // ------------------------------------------------------------------------
 
63
    // Attributes
 
64
    // ------------------------------------------------------------------------
 
65
 
 
66
    private TmfTraceElement fTrace = null;
 
67
 
 
68
    // ------------------------------------------------------------------------
 
69
    // Validation
 
70
    // ------------------------------------------------------------------------
 
71
 
 
72
    @Override
 
73
    public boolean isEnabled() {
 
74
 
 
75
        // Check if we are closing down
 
76
        final IWorkbenchWindow window = PlatformUI.getWorkbench().getActiveWorkbenchWindow();
 
77
        if (window == null)
 
78
            return false;
 
79
 
 
80
        // Get the selection
 
81
        final IWorkbenchPage page = PlatformUI.getWorkbench().getActiveWorkbenchWindow().getActivePage();
 
82
        final IWorkbenchPart part = page.getActivePart();
 
83
        final ISelectionProvider selectionProvider = part.getSite().getSelectionProvider();
 
84
        if (selectionProvider == null)
 
85
            return false;
 
86
        final ISelection selection = selectionProvider.getSelection();
 
87
 
 
88
        // Make sure there is only one selection and that it is a trace
 
89
        fTrace = null;
 
90
        if (selection instanceof TreeSelection) {
 
91
            final TreeSelection sel = (TreeSelection) selection;
 
92
            // There should be only one item selected as per the plugin.xml
 
93
            final Object element = sel.getFirstElement();
 
94
            if (element instanceof TmfTraceElement)
 
95
                fTrace = (TmfTraceElement) element;
 
96
        }
 
97
 
 
98
        // We only enable opening from the Traces folder for now
 
99
        return (fTrace != null);
 
100
    }
 
101
 
 
102
    // ------------------------------------------------------------------------
 
103
    // Execution
 
104
    // ------------------------------------------------------------------------
 
105
 
 
106
    @Override
 
107
    @SuppressWarnings({ "rawtypes", "unchecked" })
 
108
    public Object execute(final ExecutionEvent event) throws ExecutionException {
 
109
 
 
110
        // Check if we are closing down
 
111
        final IWorkbenchWindow window = PlatformUI.getWorkbench().getActiveWorkbenchWindow();
 
112
        if (window == null)
 
113
            return null;
 
114
 
 
115
        // Check that the trace is valid
 
116
        if (fTrace == null)
 
117
            return null;
 
118
 
 
119
        // If trace is under an experiment, use the original trace from the traces folder
 
120
        fTrace = fTrace.getElementUnderTraceFolder();
 
121
 
 
122
        final ITmfTrace trace = fTrace.instantiateTrace();
 
123
        final ITmfEvent traceEvent = fTrace.instantiateEvent();
 
124
        if ((trace == null) || (traceEvent == null)) {
 
125
            displayErrorMsg(Messages.OpenTraceHandler_NoTraceType);
 
126
            return null;
 
127
        }
 
128
 
 
129
        // Get the editor_id from the extension point
 
130
        final String editorId = fTrace.getEditorId();
 
131
        final boolean usesEditor = (editorId != null) && (editorId.length() > 0);
 
132
 
 
133
        try {
 
134
            trace.initTrace(fTrace.getResource(), fTrace.getLocation().getPath(), traceEvent.getClass());
 
135
        } catch (final TmfTraceException e) {
 
136
            displayErrorMsg(Messages.OpenTraceHandler_NoTrace + "\n\n" + e); //$NON-NLS-1$
 
137
            return null;
 
138
        }
 
139
 
 
140
        final IResource resource = fTrace.getResource();
 
141
        IFile file = null;
 
142
        if (resource instanceof IFile)
 
143
            file = (IFile) resource;
 
144
        else if (resource instanceof IFolder)
 
145
            try {
 
146
                final IFile bookmarksFile = fTrace.getProject().getTracesFolder().getResource().getFile(BOOKMARKS_HIDDEN_FILE);
 
147
                if (!bookmarksFile.exists()) {
 
148
                    final InputStream source = new ByteArrayInputStream(new byte[0]);
 
149
                    bookmarksFile.create(source, true, null);
 
150
                }
 
151
                bookmarksFile.setHidden(true);
 
152
 
 
153
                final IFolder folder = (IFolder) resource;
 
154
                file = folder.getFile(fTrace.getName() + '_');
 
155
                if (!file.exists())
 
156
                    file.createLink(bookmarksFile.getLocation(), IResource.REPLACE, null);
 
157
                file.setHidden(true);
 
158
                if (usesEditor)
 
159
                    file.setPersistentProperty(TmfCommonConstants.TRACETYPE, fTrace.getTraceType());
 
160
                else
 
161
                    file.setPersistentProperty(TmfCommonConstants.TRACETYPE, TmfTrace.class.getCanonicalName());
 
162
            } catch (final CoreException e) {
 
163
                Activator.getDefault().logError("Error opening trace " + fTrace.getName(), e); //$NON-NLS-1$
 
164
            }
 
165
 
 
166
        if (usesEditor)
 
167
            try {
 
168
                final IEditorInput editorInput = new TmfEditorInput(file, trace);
 
169
                final IWorkbench wb = PlatformUI.getWorkbench();
 
170
                final IWorkbenchPage activePage = wb.getActiveWorkbenchWindow().getActivePage();
 
171
 
 
172
                final IEditorPart editor = activePage.findEditor(new FileEditorInput(file));
 
173
                if ((editor != null) && (editor instanceof IReusableEditor)) {
 
174
                    activePage.reuseEditor((IReusableEditor) editor, editorInput);
 
175
                    activePage.activate(editor);
 
176
                } else {
 
177
                    activePage.openEditor(editorInput, editorId);
 
178
                    if (resource instanceof IFile)
 
179
                        IDE.setDefaultEditor((IFile) resource, editorId);
 
180
                }
 
181
            } catch (final PartInitException e) {
 
182
                Activator.getDefault().logError("Error opening trace " + fTrace.getName(), e); //$NON-NLS-1$
 
183
            }
 
184
        else {
 
185
            // Create the experiment
 
186
            final ITmfTrace[] traces = new ITmfTrace[] { trace };
 
187
            final TmfExperiment experiment = new TmfExperiment(traceEvent.getClass(), fTrace.getName(), traces, trace.getCacheSize());
 
188
            experiment.setBookmarksFile(file);
 
189
 
 
190
            TmfExperiment.setCurrentExperiment(experiment);
 
191
            TmfSignalManager.dispatchSignal(new TmfExperimentSelectedSignal(this, experiment));
 
192
            IDE.setDefaultEditor(file, EventsViewEditor.ID);
 
193
        }
 
194
        return null;
 
195
    }
 
196
 
 
197
    private void displayErrorMsg(final String errorMsg) {
 
198
        final MessageBox mb = new MessageBox(PlatformUI.getWorkbench().getActiveWorkbenchWindow().getShell());
 
199
        mb.setText(Messages.OpenTraceHandler_Title);
 
200
        mb.setMessage(errorMsg);
 
201
        mb.open();
 
202
    }
 
203
 
 
204
}