1 /*******************************************************************************
2 * Copyright (c) 2010, 2013 Ericsson
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
10 * Francois Chouinard - Initial API and implementation
11 * Bernd Hufmann - Implement getParent()
12 *******************************************************************************/
14 package org
.eclipse
.linuxtools
.tmf
.ui
.project
.model
;
16 import java
.util
.ArrayList
;
17 import java
.util
.HashMap
;
18 import java
.util
.List
;
22 import org
.eclipse
.core
.resources
.IFolder
;
23 import org
.eclipse
.core
.resources
.IProject
;
24 import org
.eclipse
.core
.resources
.IResource
;
25 import org
.eclipse
.core
.runtime
.CoreException
;
26 import org
.eclipse
.jface
.viewers
.Viewer
;
27 import org
.eclipse
.ui
.IMemento
;
28 import org
.eclipse
.ui
.navigator
.ICommonContentExtensionSite
;
29 import org
.eclipse
.ui
.navigator
.IPipelinedTreeContentProvider
;
30 import org
.eclipse
.ui
.navigator
.PipelinedShapeModification
;
31 import org
.eclipse
.ui
.navigator
.PipelinedViewerUpdate
;
34 * The TMF project content provider for the tree viewer in the project explorer view.
37 * @author Francois Chouinard
39 public class TmfNavigatorContentProvider
implements IPipelinedTreeContentProvider
{
41 // ------------------------------------------------------------------------
42 // ICommonContentProvider
43 // ------------------------------------------------------------------------
46 public Object
[] getElements(Object inputElement
) {
51 public Object
getParent(Object element
) {
52 if (element
instanceof IProject
) {
53 IProject project
= (IProject
) element
;
54 return project
.getParent();
57 if (element
instanceof TmfTraceFolder
) {
58 TmfTraceFolder folder
= (TmfTraceFolder
) element
;
59 // Return the corresponding IProject as parent because from CNF point of view the IProject is the parent.
60 // The IProject is needed e.g. for link with Editor to work correctly.
61 return folder
.getParent().getResource();
64 if (element
instanceof TmfTraceElement
) {
65 TmfTraceElement traceElement
= (TmfTraceElement
) element
;
66 return traceElement
.getParent();
69 if (element
instanceof TmfExperimentFolder
) {
70 TmfExperimentFolder folder
= (TmfExperimentFolder
) element
;
71 // Return the corresponding IProject as parent because from CNF point of view the IProject is the parent.
72 // The IProject is needed e.g. for link with Editor to work correctly.
73 return folder
.getParent().getResource();
76 if (element
instanceof TmfExperimentElement
) {
77 TmfExperimentElement expElement
= (TmfExperimentElement
) element
;
78 return expElement
.getParent();
84 public boolean hasChildren(Object element
) {
85 if (element
instanceof IProject
) {
86 IProject project
= (IProject
) element
;
87 return project
.isAccessible();
89 if (element
instanceof TmfProjectModelElement
) {
90 TmfProjectModelElement modelElement
= (TmfProjectModelElement
) element
;
91 return modelElement
.hasChildren();
97 public void dispose() {
101 public void inputChanged(Viewer viewer
, Object oldInput
, Object newInput
) {
105 public void restoreState(IMemento aMemento
) {
109 public void saveState(IMemento aMemento
) {
113 public void init(ICommonContentExtensionSite aConfig
) {
116 // ------------------------------------------------------------------------
117 // ICommonContentProvider - getChildren()
118 // ------------------------------------------------------------------------
121 public synchronized Object
[] getChildren(Object parentElement
) {
123 // Tracing project level
124 if (parentElement
instanceof IProject
) {
125 return getProjectChildren((IProject
) parentElement
);
128 // Traces "folder" level
129 if (parentElement
instanceof TmfTraceFolder
) {
130 return getTraceFolderChildren((TmfTraceFolder
) parentElement
);
133 // Experiments "folder" level
134 if (parentElement
instanceof TmfExperimentFolder
) {
135 return getExperimentFolderChildren((TmfExperimentFolder
) parentElement
);
139 if (parentElement
instanceof TmfExperimentElement
) {
140 return getExperimentChildren((TmfExperimentElement
) parentElement
);
144 if (parentElement
instanceof TmfTraceElement
) {
145 return getTraceChildren((TmfTraceElement
) parentElement
);
149 if (parentElement
instanceof TmfAnalysisElement
) {
150 return getAnalysisChildren((TmfAnalysisElement
) parentElement
);
153 return new Object
[0];
156 // ------------------------------------------------------------------------
158 // ------------------------------------------------------------------------
160 private Object
[] getProjectChildren(IProject project
) {
161 // The children structure
162 List
<Object
> children
= new ArrayList
<Object
>();
164 // Get the children from the model
165 Map
<String
, ITmfProjectModelElement
> childrenMap
= new HashMap
<String
, ITmfProjectModelElement
>();
166 TmfProjectElement tmfProject
= TmfProjectRegistry
.getProject(project
, true);
167 for (ITmfProjectModelElement element
: tmfProject
.getChildren()) {
168 if (element
instanceof TmfTraceFolder
) {
169 TmfTraceFolder child
= (TmfTraceFolder
) element
;
170 childrenMap
.put(child
.getResource().getName(), child
);
172 if (element
instanceof TmfExperimentFolder
) {
173 TmfExperimentFolder child
= (TmfExperimentFolder
) element
;
174 childrenMap
.put(child
.getResource().getName(), child
);
178 // Add the model folder if the corresponding resource exists and is not
180 IFolder folder
= project
.getFolder(TmfTraceFolder
.TRACE_FOLDER_NAME
);
181 if (folder
!= null) {
182 String name
= folder
.getName();
183 ITmfProjectModelElement element
= childrenMap
.get(name
);
184 if (element
== null) {
185 element
= new TmfTraceFolder(TmfTraceFolder
.TRACE_FOLDER_NAME
, folder
, tmfProject
);
187 children
.add(element
);
188 childrenMap
.remove(name
);
189 getTraceFolderChildren((TmfTraceFolder
) element
);
192 // Add the model folder if the corresponding resource exists and is not
194 folder
= project
.getFolder(TmfExperimentFolder
.EXPER_FOLDER_NAME
);
195 if (folder
!= null) {
196 String name
= folder
.getName();
197 ITmfProjectModelElement element
= childrenMap
.get(name
);
198 if (element
== null) {
199 element
= new TmfExperimentFolder(TmfExperimentFolder
.EXPER_FOLDER_NAME
, folder
, tmfProject
);
201 children
.add(element
);
202 childrenMap
.remove(name
);
203 getExperimentFolderChildren((TmfExperimentFolder
) element
);
206 // Remove the leftovers (what was in the model but removed from the
208 cleanupModel(tmfProject
, childrenMap
);
210 return children
.toArray();
213 private Object
[] getTraceFolderChildren(TmfTraceFolder tmfTraceFolder
) {
214 // The children structure
215 List
<Object
> children
= new ArrayList
<Object
>();
217 // Get the children from the model
218 Map
<String
, ITmfProjectModelElement
> childrenMap
= new HashMap
<String
, ITmfProjectModelElement
>();
219 for (ITmfProjectModelElement element
: tmfTraceFolder
.getChildren()) {
220 if (element
instanceof TmfTraceElement
) {
221 String name
= element
.getResource().getName();
222 childrenMap
.put(name
, element
);
226 IFolder folder
= tmfTraceFolder
.getResource();
228 IResource
[] members
= folder
.members();
229 for (IResource resource
: members
) {
230 String name
= resource
.getName();
231 ITmfProjectModelElement trace
= childrenMap
.get(name
);
233 trace
= new TmfTraceElement(name
, resource
, tmfTraceFolder
);
236 childrenMap
.remove(name
);
237 getTraceChildren((TmfTraceElement
) trace
);
239 } catch (CoreException e
) {
242 // Remove the leftovers (what was in the model but removed from the
244 cleanupModel(tmfTraceFolder
, childrenMap
);
246 return children
.toArray();
249 private Object
[] getExperimentFolderChildren(TmfExperimentFolder tmfExperimentFolder
) {
250 // The children structure
251 List
<Object
> children
= new ArrayList
<Object
>();
253 // Get the children from the model
254 Map
<String
, ITmfProjectModelElement
> childrenMap
= new HashMap
<String
, ITmfProjectModelElement
>();
255 for (ITmfProjectModelElement element
: tmfExperimentFolder
.getChildren()) {
256 if (element
instanceof TmfExperimentElement
) {
257 String name
= element
.getResource().getName();
258 childrenMap
.put(name
, element
);
262 IFolder folder
= tmfExperimentFolder
.getResource();
264 IResource
[] members
= folder
.members();
265 for (IResource resource
: members
) {
266 if (resource
instanceof IFolder
) {
267 IFolder expFolder
= (IFolder
) resource
;
268 String name
= resource
.getName();
269 ITmfProjectModelElement experiment
= childrenMap
.get(name
);
270 if (experiment
== null) {
271 experiment
= new TmfExperimentElement(name
, expFolder
, tmfExperimentFolder
);
273 children
.add(experiment
);
274 childrenMap
.remove(name
);
275 getExperimentChildren((TmfExperimentElement
) experiment
);
278 } catch (CoreException e
) {
281 // Remove the leftovers (what was in the model but removed from the
283 cleanupModel(tmfExperimentFolder
, childrenMap
);
285 return children
.toArray();
288 private Object
[] getExperimentChildren(TmfExperimentElement tmfExperiment
) {
289 // The children structure
290 List
<Object
> children
= new ArrayList
<Object
>();
292 // Get the children from the model
293 Map
<String
, ITmfProjectModelElement
> childrenMap
= new HashMap
<String
, ITmfProjectModelElement
>();
294 for (ITmfProjectModelElement element
: tmfExperiment
.getChildren()) {
295 if (element
instanceof TmfTraceElement
) {
296 String name
= element
.getResource().getName();
297 childrenMap
.put(name
, element
);
301 IFolder folder
= tmfExperiment
.getResource();
303 IResource
[] members
= folder
.members();
304 for (IResource resource
: members
) {
305 String name
= resource
.getName();
306 ITmfProjectModelElement trace
= childrenMap
.get(name
);
307 if (trace
== null && !resource
.isHidden()) {
308 // exclude hidden resources (e.g. bookmarks file)
309 trace
= new TmfTraceElement(name
, resource
, tmfExperiment
);
312 childrenMap
.remove(name
);
314 } catch (CoreException e
) {
317 // Remove the leftovers (what was in the model but removed from the
319 cleanupModel(tmfExperiment
, childrenMap
);
321 for (TmfAnalysisElement analysis
: tmfExperiment
.getAvailableAnalysis()) {
322 children
.add(analysis
);
325 return children
.toArray();
328 private static Object
[] getTraceChildren(TmfTraceElement parentElement
) {
329 // The children structure
330 List
<Object
> children
= new ArrayList
<Object
>();
332 for (TmfAnalysisElement analysis
: parentElement
.getAvailableAnalysis()) {
333 children
.add(analysis
);
336 return children
.toArray();
339 private static Object
[] getAnalysisChildren(TmfAnalysisElement parentElement
) {
340 // The children structure
341 List
<Object
> children
= new ArrayList
<Object
>();
343 for (TmfAnalysisOutputElement output
: parentElement
.getAvailableOutputs()) {
344 children
.add(output
);
347 return children
.toArray();
350 private void cleanupModel(ITmfProjectModelElement parent
, Map
<String
, ITmfProjectModelElement
> danglingChildren
) {
351 if (parent
!= null) {
352 for (ITmfProjectModelElement child
: danglingChildren
.values()) {
353 Map
<String
, ITmfProjectModelElement
> grandChildren
= new HashMap
<String
, ITmfProjectModelElement
>();
354 for (ITmfProjectModelElement element
: child
.getChildren()) {
355 String name
= element
.getResource().getName();
356 grandChildren
.put(name
, element
);
358 cleanupModel(child
, grandChildren
);
359 parent
.removeChild(child
);
364 // ------------------------------------------------------------------------
365 // IPipelinedTreeContentProvider
366 // ------------------------------------------------------------------------
369 public void getPipelinedChildren(Object parent
, Set currentChildren
) {
370 customizeTmfElements(getChildren(parent
), currentChildren
);
374 public void getPipelinedElements(Object input
, Set currentElements
) {
375 customizeTmfElements(getElements(input
), currentElements
);
379 * Add/replace the ITmfProjectElement to the list of children
382 * the list returned by getChildren()
384 * the current children
386 private static void customizeTmfElements(Object
[] elements
,
387 Set
<Object
> children
) {
388 if (elements
!= null && children
!= null) {
389 for (Object element
: elements
) {
390 if (element
instanceof ITmfProjectModelElement
) {
391 ITmfProjectModelElement tmfElement
= (ITmfProjectModelElement
) element
;
392 IResource resource
= tmfElement
.getResource();
393 if (resource
!= null) {
394 children
.remove(resource
);
396 children
.add(element
);
398 else if (element
!= null) {
399 children
.add(element
);
406 public Object
getPipelinedParent(Object anObject
, Object aSuggestedParent
) {
407 return aSuggestedParent
;
411 public PipelinedShapeModification
interceptAdd(PipelinedShapeModification anAddModification
) {
412 return anAddModification
;
416 public PipelinedShapeModification
interceptRemove(PipelinedShapeModification aRemoveModification
) {
421 public boolean interceptRefresh(PipelinedViewerUpdate aRefreshSynchronization
) {
426 public boolean interceptUpdate(PipelinedViewerUpdate anUpdateSynchronization
) {