← Back to branch summary

~ubuntu-branches/ubuntu/wily/eclipse-linuxtools/wily

« 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/SelectTraceTypeHandler.java

  • Committer: Package Import Robot
  • Author(s): Jakub Adam, Jakub Adam, tony mancill
  • Date: 2014-10-11 11:44:05 UTC
  • mfrom: (1.2.4)
  • Revision ID: package-import@ubuntu.com-20141011114405-yazjvxfzzhmi5sgj
Tags: 3.1.0-1
http://bugs.debian.org/761524
[ Jakub Adam ]
* New upstream release (Closes: #761524).
* Refreshed d/patches.
* Don't build removed feature org.eclipse.linuxtools.tools.launch
  - merged into org.eclipse.linuxtools.profiling.
* Use javac target 1.7.
* Build new feature org.eclipse.linuxtools.dataviewers.feature
  - required by Valgrind integration.
* Build-depend on eclipse-remote-services-api and eclipse-cdt-autotools.
* Bump Standards-Version to 3.9.6.
* Override incompatible-java-bytecode-format - linuxtools needs Java 7.
* Remove unused codeless-jar override.

[ tony mancill ]
* Tweak short package description to make lintian happy.

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/SelectTraceTypeHandler.java
1
1
/*******************************************************************************
2
 
 * Copyright (c) 2011, 2013 Ericsson
 
2
 * Copyright (c) 2011, 2014 Ericsson, École Polytechnique de Montréal
3
3
 *
4
4
 * All rights reserved. This program and the accompanying materials are
5
5
 * made available under the terms of the Eclipse Public License v1.0 which
9
9
 * Contributors:
10
10
 *   Francois Chouinard - Initial API and implementation
11
11
 *   Patrick Tasse - Fix propagation to experiment traces
 
12
 *   Geneviève Bastien - Add support of experiment types
12
13
 *******************************************************************************/
13
14
 
14
15
package org.eclipse.linuxtools.internal.tmf.ui.project.handlers;
15
16
 
16
17
import java.util.ArrayList;
 
18
import java.util.HashSet;
17
19
import java.util.Iterator;
18
20
import java.util.List;
 
21
import java.util.Set;
19
22
 
20
23
import org.eclipse.core.commands.AbstractHandler;
21
24
import org.eclipse.core.commands.ExecutionEvent;
22
25
import org.eclipse.core.commands.ExecutionException;
23
 
import org.eclipse.core.resources.IProject;
24
26
import org.eclipse.core.resources.IResource;
25
27
import org.eclipse.core.runtime.CoreException;
26
28
import org.eclipse.core.runtime.IStatus;
31
33
import org.eclipse.jface.viewers.ISelectionProvider;
32
34
import org.eclipse.jface.viewers.TreeSelection;
33
35
import org.eclipse.linuxtools.internal.tmf.ui.Activator;
34
 
import org.eclipse.linuxtools.tmf.core.TmfCommonConstants;
35
 
import org.eclipse.linuxtools.tmf.core.trace.ITmfTrace;
36
 
import org.eclipse.linuxtools.tmf.ui.project.model.ITmfProjectModelElement;
 
36
import org.eclipse.linuxtools.tmf.core.project.model.TmfTraceType;
 
37
import org.eclipse.linuxtools.tmf.core.project.model.TraceTypeHelper;
 
38
import org.eclipse.linuxtools.tmf.ui.project.model.TmfCommonProjectElement;
 
39
import org.eclipse.linuxtools.tmf.ui.project.model.TmfExperimentElement;
37
40
import org.eclipse.linuxtools.tmf.ui.project.model.TmfExperimentFolder;
 
41
import org.eclipse.linuxtools.tmf.ui.project.model.TmfProjectElement;
38
42
import org.eclipse.linuxtools.tmf.ui.project.model.TmfTraceElement;
39
 
import org.eclipse.linuxtools.tmf.ui.project.model.TmfTraceFolder;
 
43
import org.eclipse.linuxtools.tmf.ui.project.model.TmfTraceTypeUIUtils;
40
44
import org.eclipse.swt.widgets.Shell;
41
45
import org.eclipse.ui.IWorkbenchPage;
42
46
import org.eclipse.ui.IWorkbenchPart;
53
57
    // Constants
54
58
    // ------------------------------------------------------------------------
55
59
 
56
 
    private static final String BUNDLE_PARAMETER = "org.eclipse.linuxtools.tmf.ui.commandparameter.select_trace_type.bundle"; //$NON-NLS-1$
57
60
    private static final String TYPE_PARAMETER = "org.eclipse.linuxtools.tmf.ui.commandparameter.select_trace_type.type"; //$NON-NLS-1$
58
 
    private static final String ICON_PARAMETER = "org.eclipse.linuxtools.tmf.ui.commandparameter.select_trace_type.icon"; //$NON-NLS-1$
59
61
 
60
62
    // ------------------------------------------------------------------------
61
63
    // Attributes
95
97
            Iterator<Object> iterator = fSelection.iterator();
96
98
            while (iterator.hasNext()) {
97
99
                Object element = iterator.next();
98
 
                if (!(element instanceof TmfTraceElement)) {
 
100
                if (!(element instanceof TmfCommonProjectElement)) {
99
101
                    return false;
100
102
                }
101
103
            }
117
119
        if (window == null) {
118
120
            return null;
119
121
        }
120
 
        List<IStatus> statuses = new ArrayList<IStatus>();
 
122
        List<IStatus> statuses = new ArrayList<>();
 
123
        Set<TmfProjectElement> projects = new HashSet<>();
121
124
        boolean ok = true;
122
125
        for (Object element : fSelection.toList()) {
123
 
            TmfTraceElement trace = (TmfTraceElement) element;
124
 
            trace = trace.getElementUnderTraceFolder();
 
126
            TmfCommonProjectElement trace = (TmfCommonProjectElement) element;
 
127
            if (trace instanceof TmfTraceElement) {
 
128
                trace = ((TmfTraceElement) trace).getElementUnderTraceFolder();
 
129
            }
125
130
            IResource resource = trace.getResource();
126
131
            if (resource != null) {
127
132
                try {
128
 
                    // Set the properties for this resource
129
 
                    String bundleName = event.getParameter(BUNDLE_PARAMETER);
 
133
                    // Set the trace type for this resource
130
134
                    String traceType = event.getParameter(TYPE_PARAMETER);
131
 
                    String iconUrl = event.getParameter(ICON_PARAMETER);
132
135
                    String previousTraceType = trace.getTraceType();
133
 
                    IStatus status = propagateProperties(trace, bundleName, traceType, iconUrl);
 
136
                    IStatus status = propagateProperties(trace, traceType);
134
137
                    ok &= status.isOK();
135
138
 
136
139
                    if (status.isOK()) {
143
146
                    } else {
144
147
                        statuses.add(status);
145
148
                    }
 
149
                    projects.add(trace.getProject());
146
150
                } catch (CoreException e) {
147
151
                    Activator.getDefault().logError(Messages.SelectTraceTypeHandler_ErrorSelectingTrace + trace.getName(), e);
148
152
                }
149
153
            }
150
 
        }
151
 
        ((ITmfProjectModelElement) fSelection.getFirstElement()).getProject().refresh();
 
154
            trace.getProject();
 
155
        }
 
156
        for (TmfProjectElement project : projects) {
 
157
            project.refresh();
 
158
        }
152
159
 
153
160
        if (!ok) {
154
161
            final Shell shell = window.getShell();
165
172
        return null;
166
173
    }
167
174
 
168
 
    private static IStatus propagateProperties(TmfTraceElement trace,
169
 
            String bundleName, String traceType, String iconUrl)
 
175
    private static IStatus propagateProperties(TmfCommonProjectElement element, String traceType)
170
176
            throws CoreException {
171
177
 
172
 
        IResource svResource = trace.getResource();
173
 
        String svBundleName = svResource.getPersistentProperty(TmfCommonConstants.TRACEBUNDLE);
174
 
        String svTraceType = svResource.getPersistentProperty(TmfCommonConstants.TRACETYPE);
175
 
        String svIconUrl = svResource.getPersistentProperty(TmfCommonConstants.TRACEICON);
176
 
 
177
 
        setProperties(trace.getResource(), bundleName, traceType, iconUrl);
178
 
        trace.refreshTraceType();
179
 
        final IStatus validateTraceType = validateTraceType(trace);
 
178
        TraceTypeHelper traceTypeHelper = TmfTraceType.getTraceType(traceType);
 
179
        if (traceTypeHelper == null) {
 
180
            return Status.CANCEL_STATUS;
 
181
        }
 
182
        final IStatus validateTraceType = traceTypeHelper.validate(element.getResource().getLocation().toOSString());
180
183
        if (!validateTraceType.isOK()) {
181
 
            setProperties(trace.getResource(), svBundleName, svTraceType, svIconUrl);
182
 
            trace.refreshTraceType();
183
184
            return validateTraceType;
184
185
        }
185
186
 
186
 
        trace.refreshTraceType();
 
187
        IResource resource = element.getResource();
 
188
        TmfTraceTypeUIUtils.setTraceType(resource, traceTypeHelper);
187
189
 
188
 
        if (trace.getParent() instanceof TmfTraceFolder) {
189
 
            TmfExperimentFolder experimentFolder = trace.getProject().getExperimentsFolder();
190
 
            for (final ITmfProjectModelElement experiment : experimentFolder.getChildren()) {
191
 
                for (final ITmfProjectModelElement child : experiment.getChildren()) {
192
 
                    if (child instanceof TmfTraceElement) {
193
 
                        TmfTraceElement linkedTrace = (TmfTraceElement) child;
194
 
                        if (linkedTrace.getName().equals(trace.getName())) {
195
 
                            IResource resource = linkedTrace.getResource();
196
 
                            setProperties(resource, bundleName, traceType, iconUrl);
197
 
                            linkedTrace.refreshTraceType();
198
 
                        }
199
 
                    }
 
190
        TmfExperimentFolder experimentFolder = element.getProject().getExperimentsFolder();
 
191
        for (final TmfExperimentElement experiment : experimentFolder.getExperiments()) {
 
192
            for (final TmfTraceElement child : experiment.getTraces()) {
 
193
                if (child.getName().equals(element.getName())) {
 
194
                    TmfTraceTypeUIUtils.setTraceType(child.getResource(), traceTypeHelper);
 
195
                    break;
200
196
                }
201
197
            }
202
198
        }
204
200
        return Status.OK_STATUS;
205
201
    }
206
202
 
207
 
    private static void setProperties(IResource resource, String bundleName,
208
 
            String traceType, String iconUrl) throws CoreException {
209
 
        resource.setPersistentProperty(TmfCommonConstants.TRACEBUNDLE, bundleName);
210
 
        resource.setPersistentProperty(TmfCommonConstants.TRACETYPE, traceType);
211
 
        resource.setPersistentProperty(TmfCommonConstants.TRACEICON, iconUrl);
212
 
    }
213
 
 
214
 
    private static IStatus validateTraceType(TmfTraceElement trace) {
215
 
        IProject project = trace.getProject().getResource();
216
 
        ITmfTrace tmfTrace = null;
217
 
        IStatus validate = null;
218
 
        try {
219
 
            tmfTrace = trace.instantiateTrace();
220
 
            if (tmfTrace != null) {
221
 
                validate = tmfTrace.validate(project, trace.getLocation().getPath());
222
 
            }
223
 
            else{
224
 
                validate =  new Status(IStatus.ERROR, trace.getName(), "File does not exist : " + trace.getLocation().getPath()); //$NON-NLS-1$
225
 
            }
226
 
        } finally {
227
 
            if (tmfTrace != null) {
228
 
                tmfTrace.dispose();
229
 
            }
230
 
        }
231
 
        if (validate == null) {
232
 
            validate = new Status(IStatus.ERROR, "unknown", "unknown"); //$NON-NLS-1$ //$NON-NLS-2$
233
 
        }
234
 
        return validate;
235
 
    }
236
 
 
237
203
}