server/plugins/org.argeo.jcr.ui.explorer/src/main/java/org/argeo/jcr/ui/explorer/providers/FullVersioningTreeContentProvider.java

   1 /*
   2  * Copyright (C) 2007-2012 Mathieu Baudier
   3  *
   4  * Licensed under the Apache License, Version 2.0 (the "License");
   5  * you may not use this file except in compliance with the License.
   6  * You may obtain a copy of the License at
   7  *
   8  *         http://www.apache.org/licenses/LICENSE-2.0
   9  *
  10  * Unless required by applicable law or agreed to in writing, software
  11  * distributed under the License is distributed on an "AS IS" BASIS,
  12  * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
  13  * See the License for the specific language governing permissions and
  14  * limitations under the License.
  15  */
  16 package org.argeo.jcr.ui.explorer.providers;
  17
  18 import java.util.ArrayList;
  19 import java.util.List;
  20
  21 import javax.jcr.Node;
  22 import javax.jcr.RepositoryException;
  23 import javax.jcr.nodetype.NodeType;
  24 import javax.jcr.version.Version;
  25 import javax.jcr.version.VersionHistory;
  26 import javax.jcr.version.VersionIterator;
  27 import javax.jcr.version.VersionManager;
  28
  29 import org.argeo.ArgeoException;
  30 import org.eclipse.jface.viewers.ITreeContentProvider;
  31 import org.eclipse.jface.viewers.Viewer;
  32
  33 /**
  34  * Implementation of the {@code ITreeContentProvider} in order to display some
  35  * version informations of a JCR full versionable node in a tree like structure
  36  *
  37  */
  38 public class FullVersioningTreeContentProvider implements ITreeContentProvider {
  39         // private Node rootNode;
  40         // private ItemComparator itemComparator = new ItemComparator();
  41
  42         /**
  43          * Sends back the first level of the Tree. input element must be a single
  44          * node object
  45          */
  46         public Object[] getElements(Object inputElement) {
  47                 try {
  48                         Node rootNode = (Node) inputElement;
  49                         String curPath = rootNode.getPath();
  50                         VersionManager vm = rootNode.getSession().getWorkspace()
  51                                         .getVersionManager();
  52
  53                         VersionHistory vh = vm.getVersionHistory(curPath);
  54                         List<Version> result = new ArrayList<Version>();
  55                         VersionIterator vi = vh.getAllLinearVersions();
  56
  57                         while (vi.hasNext()) {
  58                                 result.add(vi.nextVersion());
  59                         }
  60                         return result.toArray();
  61                 } catch (RepositoryException re) {
  62                         throw new ArgeoException(
  63                                         "Unexpected error while getting version elements", re);
  64                 }
  65         }
  66
  67         public Object[] getChildren(Object parentElement) {
  68                 try {
  69                         if (parentElement instanceof Version) {
  70                                 List<Node> tmp = new ArrayList<Node>();
  71                                 tmp.add(((Version) parentElement).getFrozenNode());
  72                                 return tmp.toArray();
  73                         }
  74                 } catch (RepositoryException re) {
  75                         throw new ArgeoException("Unexpected error while getting child "
  76                                         + "node for version element", re);
  77                 }
  78                 return null;
  79         }
  80
  81         public Object getParent(Object element) {
  82                 try {
  83                         // this will not work in a simpleVersionning environment, parent is
  84                         // not a node.
  85                         if (element instanceof Node
  86                                         && ((Node) element).isNodeType(NodeType.NT_FROZEN_NODE)) {
  87                                 Node node = (Node) element;
  88                                 return node.getParent();
  89                         } else
  90                                 return null;
  91                 } catch (RepositoryException e) {
  92                         return null;
  93                 }
  94         }
  95
  96         public boolean hasChildren(Object element) {
  97                 try {
  98                         if (element instanceof Version)
  99                                 return true;
 100                         else if (element instanceof Node)
 101                                 return ((Node) element).hasNodes();
 102                         else
 103                                 return false;
 104                 } catch (RepositoryException e) {
 105                         throw new ArgeoException("Cannot check children of " + element, e);
 106                 }
 107         }
 108
 109         public void dispose() {
 110         }
 111
 112         public void inputChanged(Viewer viewer, Object oldInput, Object newInput) {
 113         }
 114
 115 }