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

   1 /*******************************************************************************
   2  * Copyright (c) 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.tmf.ui.project.model;
  14
  15 import java.util.ArrayList;
  16 import java.util.HashMap;
  17 import java.util.List;
  18 import java.util.Map;
  19 import java.util.Set;
  20
  21 import org.eclipse.core.resources.IFolder;
  22 import org.eclipse.core.resources.IProject;
  23 import org.eclipse.core.resources.IResource;
  24 import org.eclipse.core.runtime.CoreException;
  25 import org.eclipse.jface.viewers.Viewer;
  26 import org.eclipse.ui.IMemento;
  27 import org.eclipse.ui.navigator.ICommonContentExtensionSite;
  28 import org.eclipse.ui.navigator.ICommonContentProvider;
  29 import org.eclipse.ui.navigator.IPipelinedTreeContentProvider;
  30 import org.eclipse.ui.navigator.PipelinedShapeModification;
  31 import org.eclipse.ui.navigator.PipelinedViewerUpdate;
  32
  33 /**
  34  * <b><u>TmfNavigatorContentProvider</u></b>
  35  * <p>
  36  */
  37 public class TmfNavigatorContentProvider implements ICommonContentProvider, IPipelinedTreeContentProvider {
  38
  39     // ------------------------------------------------------------------------
  40     // ICommonContentProvider
  41     // ------------------------------------------------------------------------
  42
  43     @Override
  44     public Object[] getElements(Object inputElement) {
  45         return null;
  46     }
  47
  48     @Override
  49     public Object getParent(Object element) {
  50         return null;
  51     }
  52
  53     @Override
  54     public boolean hasChildren(Object element) {
  55         if (element instanceof IProject) {
  56             IProject project = (IProject) element;
  57             return project.isAccessible();
  58         }
  59         if (element instanceof TmfTraceFolder) {
  60             TmfTraceFolder folder = (TmfTraceFolder) element;
  61             return folder.hasChildren();
  62         }
  63         if (element instanceof TmfExperimentFolder) {
  64             TmfExperimentFolder folder = (TmfExperimentFolder) element;
  65             return folder.hasChildren();
  66         }
  67         if (element instanceof TmfExperimentElement) {
  68             TmfExperimentElement folder = (TmfExperimentElement) element;
  69             return folder.hasChildren();
  70         }
  71         return false;
  72     }
  73
  74     @Override
  75     public void dispose() {
  76     }
  77
  78     @Override
  79     public void inputChanged(Viewer viewer, Object oldInput, Object newInput) {
  80     }
  81
  82     @Override
  83     public void restoreState(IMemento aMemento) {
  84     }
  85
  86     @Override
  87     public void saveState(IMemento aMemento) {
  88     }
  89
  90     @Override
  91     public void init(ICommonContentExtensionSite aConfig) {
  92     }
  93
  94     // ------------------------------------------------------------------------
  95     // ICommonContentProvider - getChildren()
  96     // ------------------------------------------------------------------------
  97
  98     @Override
  99     public synchronized Object[] getChildren(Object parentElement) {
 100
 101         // Tracing project level
 102         if (parentElement instanceof IProject) {
 103             return getProjectChildren((IProject) parentElement);
 104         }
 105
 106         // Traces "folder" level
 107         if (parentElement instanceof TmfTraceFolder) {
 108             return getTraceFolderChildren((TmfTraceFolder) parentElement);
 109         }
 110
 111         // Experiments "folder" level
 112         if (parentElement instanceof TmfExperimentFolder) {
 113             return getExperimentFolderChildren((TmfExperimentFolder) parentElement);
 114         }
 115
 116         // Experiment
 117         if (parentElement instanceof TmfExperimentElement) {
 118             return getExperimentChildren((TmfExperimentElement) parentElement);
 119         }
 120
 121         return new Object[0];
 122     }
 123
 124     private Object[] getProjectChildren(IProject project) {
 125         // The children structure
 126         List<Object> children = new ArrayList<Object>();
 127
 128         // Get the children from the model
 129         Map<String, ITmfProjectModelElement> childrenMap = new HashMap<String, ITmfProjectModelElement>();
 130         TmfProjectElement tmfProject = TmfProjectRegistry.getProject(project, true);
 131         for (ITmfProjectModelElement element : tmfProject.getChildren()) {
 132             if (element instanceof TmfTraceFolder) {
 133                 TmfTraceFolder child = (TmfTraceFolder) element;
 134                 childrenMap.put(child.getResource().getName(), child);
 135             }
 136             if (element instanceof TmfExperimentFolder) {
 137                 TmfExperimentFolder child = (TmfExperimentFolder) element;
 138                 childrenMap.put(child.getResource().getName(), child);
 139             }
 140         }
 141
 142         // Add the model folder if the corresponding resource exists and is not
 143         // accounted for
 144         IFolder folder = project.getFolder(TmfTraceFolder.TRACE_FOLDER_NAME);
 145         if (folder != null) {
 146             String name = folder.getName();
 147             ITmfProjectModelElement element = childrenMap.get(name);
 148             if (element == null) {
 149                 element = new TmfTraceFolder(TmfTraceFolder.TRACE_FOLDER_NAME, folder, tmfProject);
 150             }
 151             children.add(element);
 152             childrenMap.remove(name);
 153             getTraceFolderChildren((TmfTraceFolder) element);
 154         }
 155
 156         // Add the model folder if the corresponding resource exists and is not
 157         // accounted for
 158         folder = project.getFolder(TmfExperimentFolder.EXPER_FOLDER_NAME);
 159         if (folder != null) {
 160             String name = folder.getName();
 161             ITmfProjectModelElement element = childrenMap.get(name);
 162             if (element == null) {
 163                 element = new TmfExperimentFolder(TmfExperimentFolder.EXPER_FOLDER_NAME, folder, tmfProject);
 164             }
 165             children.add(element);
 166             childrenMap.remove(name);
 167             getExperimentFolderChildren((TmfExperimentFolder) element);
 168         }
 169
 170         // Remove the leftovers (what was in the model but removed from the
 171         // project)
 172         cleanupModel(tmfProject, childrenMap);
 173
 174         return children.toArray();
 175     }
 176
 177     private Object[] getTraceFolderChildren(TmfTraceFolder tmfTraceFolder) {
 178         // The children structure
 179         List<Object> children = new ArrayList<Object>();
 180
 181         // Get the children from the model
 182         Map<String, ITmfProjectModelElement> childrenMap = new HashMap<String, ITmfProjectModelElement>();
 183         for (ITmfProjectModelElement element : tmfTraceFolder.getChildren()) {
 184             if (element instanceof TmfTraceElement) {
 185                 String name = element.getResource().getName();
 186                 childrenMap.put(name, element);
 187             }
 188         }
 189
 190         IFolder folder = tmfTraceFolder.getResource();
 191         try {
 192             IResource[] members = folder.members();
 193             for (IResource resource : members) {
 194                 String name = resource.getName();
 195                 ITmfProjectModelElement trace = childrenMap.get(name);
 196                 if (!name.startsWith(TmfTraceElement.SUPPLEMENATARY_FILES_PREFIX)) {
 197                     if (trace == null) {
 198                         trace = new TmfTraceElement(name, resource, tmfTraceFolder);
 199                     }
 200                     children.add(trace);
 201                 }
 202                 childrenMap.remove(name);
 203             }
 204         } catch (CoreException e) {
 205         }
 206
 207         // Remove the leftovers (what was in the model but removed from the
 208         // project)
 209         cleanupModel(tmfTraceFolder, childrenMap);
 210
 211         return children.toArray();
 212     }
 213
 214     private Object[] getExperimentFolderChildren(TmfExperimentFolder tmfExperimentFolder) {
 215         // The children structure
 216         List<Object> children = new ArrayList<Object>();
 217
 218         // Get the children from the model
 219         Map<String, ITmfProjectModelElement> childrenMap = new HashMap<String, ITmfProjectModelElement>();
 220         for (ITmfProjectModelElement element : tmfExperimentFolder.getChildren()) {
 221             if (element instanceof TmfExperimentElement) {
 222                 String name = element.getResource().getName();
 223                 childrenMap.put(name, element);
 224             }
 225         }
 226
 227         IFolder folder = tmfExperimentFolder.getResource();
 228         try {
 229             IResource[] members = folder.members();
 230             for (IResource resource : members) {
 231                 if (resource instanceof IFolder) {
 232                     IFolder expFolder = (IFolder) resource;
 233                     String name = resource.getName();
 234                     ITmfProjectModelElement experiment = childrenMap.get(name);
 235                     if (experiment == null) {
 236                         experiment = new TmfExperimentElement(name, expFolder, tmfExperimentFolder);
 237                     }
 238                     children.add(experiment);
 239                     childrenMap.remove(name);
 240                     getExperimentChildren((TmfExperimentElement) experiment);
 241                 }
 242             }
 243         } catch (CoreException e) {
 244         }
 245
 246         // Remove the leftovers (what was in the model but removed from the
 247         // project)
 248         cleanupModel(tmfExperimentFolder, childrenMap);
 249
 250         return children.toArray();
 251     }
 252
 253     private Object[] getExperimentChildren(TmfExperimentElement tmfExperiment) {
 254         // The children structure
 255         List<Object> children = new ArrayList<Object>();
 256
 257         // Get the children from the model
 258         Map<String, ITmfProjectModelElement> childrenMap = new HashMap<String, ITmfProjectModelElement>();
 259         for (ITmfProjectModelElement element : tmfExperiment.getChildren()) {
 260             if (element instanceof TmfTraceElement) {
 261                 String name = element.getResource().getName();
 262                 childrenMap.put(name, element);
 263             }
 264         }
 265
 266         IFolder folder = tmfExperiment.getResource();
 267         try {
 268             IResource[] members = folder.members();
 269             for (IResource resource : members) {
 270                 String name = resource.getName();
 271                 ITmfProjectModelElement trace = childrenMap.get(name);
 272                 if (trace == null && !resource.isHidden()) {
 273                     // exclude hidden resources (e.g. bookmarks file)
 274                     trace = new TmfTraceElement(name, resource, tmfExperiment);
 275                 }
 276                 children.add(trace);
 277                 childrenMap.remove(name);
 278             }
 279         } catch (CoreException e) {
 280         }
 281
 282         // Remove the leftovers (what was in the model but removed from the
 283         // project)
 284         cleanupModel(tmfExperiment, childrenMap);
 285
 286         return children.toArray();
 287     }
 288
 289     private void cleanupModel(ITmfProjectModelElement parent, Map<String, ITmfProjectModelElement> danglingChildren) {
 290         if (parent != null) {
 291             for (ITmfProjectModelElement child : danglingChildren.values()) {
 292                 Map<String, ITmfProjectModelElement> grandChildren = new HashMap<String, ITmfProjectModelElement>();
 293                 for (ITmfProjectModelElement element : child.getChildren()) {
 294                     String name = element.getResource().getName();
 295                     grandChildren.put(name, element);
 296                 }
 297                 cleanupModel(child, grandChildren);
 298                 parent.removeChild(child);
 299             }
 300         }
 301     }
 302
 303     // ------------------------------------------------------------------------
 304     // IPipelinedTreeContentProvider
 305     // ------------------------------------------------------------------------
 306
 307     @Override
 308     @SuppressWarnings({ "rawtypes", "unchecked" })
 309     public void getPipelinedChildren(Object parent, Set currentChildren) {
 310         customizeTmfElements(getChildren(parent), currentChildren);
 311     }
 312
 313     @Override
 314     @SuppressWarnings({ "rawtypes", "unchecked" })
 315     public void getPipelinedElements(Object input, Set currentElements) {
 316         customizeTmfElements(getElements(input), currentElements);
 317     }
 318
 319     /**
 320      * Add/replace the ITmfProjectElement to the list of children
 321      *
 322      * @param elements
 323      *            the list returned by getChildren()
 324      * @param children
 325      *            the current children
 326      */
 327     private void customizeTmfElements(Object[] elements, Set<Object> children) {
 328         if (elements != null && children != null) {
 329             for (Object element : elements) {
 330                 if (element instanceof ITmfProjectModelElement) {
 331                     ITmfProjectModelElement tmfElement = (ITmfProjectModelElement) element;
 332                     IResource resource = tmfElement.getResource();
 333                     if (resource != null) {
 334                         children.remove(resource);
 335                     }
 336                     children.add(element);
 337                 }
 338                 else if (element != null) {
 339                     children.add(element);
 340                 }
 341             }
 342         }
 343     }
 344
 345     @Override
 346     public Object getPipelinedParent(Object anObject, Object aSuggestedParent) {
 347         return aSuggestedParent;
 348     }
 349
 350     @Override
 351     public PipelinedShapeModification interceptAdd(PipelinedShapeModification anAddModification) {
 352         return anAddModification;
 353     }
 354
 355     @Override
 356     public PipelinedShapeModification interceptRemove(PipelinedShapeModification aRemoveModification) {
 357         return null;
 358     }
 359
 360     @Override
 361     public boolean interceptRefresh(PipelinedViewerUpdate aRefreshSynchronization) {
 362         return false;
 363     }
 364
 365     @Override
 366     public boolean interceptUpdate(PipelinedViewerUpdate anUpdateSynchronization) {
 367         return false;
 368     }
 369
 370 }