eclipse/plugins/org.argeo.eclipse.ui.jcr/src/main/java/org/argeo/eclipse/ui/jcr/views/GenericJcrBrowser.java

   1 package org.argeo.eclipse.ui.jcr.views;
   2
   3 import java.util.ArrayList;
   4 import java.util.Arrays;
   5 import java.util.Comparator;
   6 import java.util.List;
   7 import java.util.Set;
   8 import java.util.TreeSet;
   9
  10 import javax.jcr.Item;
  11 import javax.jcr.Node;
  12 import javax.jcr.NodeIterator;
  13 import javax.jcr.Property;
  14 import javax.jcr.PropertyIterator;
  15 import javax.jcr.PropertyType;
  16 import javax.jcr.RepositoryException;
  17 import javax.jcr.Session;
  18 import javax.jcr.nodetype.NodeType;
  19
  20 import org.apache.commons.logging.Log;
  21 import org.apache.commons.logging.LogFactory;
  22 import org.argeo.ArgeoException;
  23 import org.eclipse.jface.viewers.ColumnLabelProvider;
  24 import org.eclipse.jface.viewers.ISelectionChangedListener;
  25 import org.eclipse.jface.viewers.IStructuredContentProvider;
  26 import org.eclipse.jface.viewers.IStructuredSelection;
  27 import org.eclipse.jface.viewers.ITreeContentProvider;
  28 import org.eclipse.jface.viewers.LabelProvider;
  29 import org.eclipse.jface.viewers.SelectionChangedEvent;
  30 import org.eclipse.jface.viewers.TableViewer;
  31 import org.eclipse.jface.viewers.TableViewerColumn;
  32 import org.eclipse.jface.viewers.TreeViewer;
  33 import org.eclipse.jface.viewers.Viewer;
  34 import org.eclipse.swt.SWT;
  35 import org.eclipse.swt.custom.SashForm;
  36 import org.eclipse.swt.layout.FillLayout;
  37 import org.eclipse.swt.layout.GridData;
  38 import org.eclipse.swt.layout.GridLayout;
  39 import org.eclipse.swt.widgets.Composite;
  40 import org.eclipse.ui.part.ViewPart;
  41
  42 public class GenericJcrBrowser extends ViewPart {
  43         private final static Log log = LogFactory.getLog(GenericJcrBrowser.class);
  44
  45         private TreeViewer nodesViewer;
  46         private TableViewer propertiesViewer;
  47
  48         private Session jcrSession;
  49
  50         private Comparator<Item> itemComparator = new Comparator<Item>() {
  51                 public int compare(Item o1, Item o2) {
  52                         try {
  53                                 return o1.getName().compareTo(o2.getName());
  54                         } catch (RepositoryException e) {
  55                                 throw new ArgeoException("Cannot compare " + o1 + " and " + o2,
  56                                                 e);
  57                         }
  58                 }
  59         };
  60
  61         @Override
  62         public void createPartControl(Composite parent) {
  63                 parent.setLayout(new FillLayout());
  64
  65                 SashForm sashForm = new SashForm(parent, SWT.VERTICAL);
  66                 sashForm.setSashWidth(4);
  67                 sashForm.setLayout(new FillLayout());
  68
  69                 Composite top = new Composite(sashForm, SWT.NONE);
  70                 GridLayout gl = new GridLayout(1, false);
  71                 top.setLayout(gl);
  72
  73                 nodesViewer = new TreeViewer(top, SWT.MULTI | SWT.H_SCROLL
  74                                 | SWT.V_SCROLL);
  75                 nodesViewer.getTree().setLayoutData(
  76                                 new GridData(SWT.FILL, SWT.FILL, true, true));
  77                 nodesViewer.setContentProvider(new NodeContentProvider());
  78                 nodesViewer.setLabelProvider(new NodeLabelProvider());
  79                 nodesViewer
  80                                 .addSelectionChangedListener(new ISelectionChangedListener() {
  81                                         public void selectionChanged(SelectionChangedEvent event) {
  82                                                 if (!event.getSelection().isEmpty()) {
  83                                                         IStructuredSelection sel = (IStructuredSelection) event
  84                                                                         .getSelection();
  85                                                         log.debug(sel.getFirstElement().getClass());
  86                                                         propertiesViewer.setInput(sel.getFirstElement());
  87                                                 } else {
  88                                                         propertiesViewer.setInput(getViewSite());
  89                                                 }
  90                                         }
  91                                 });
  92                 try {
  93                         nodesViewer.setInput(jcrSession.getRootNode());
  94                 } catch (RepositoryException e) {
  95                         throw new ArgeoException("Cannot initialize view", e);
  96                 }
  97
  98                 Composite bottom = new Composite(sashForm, SWT.NONE);
  99                 bottom.setLayout(new GridLayout(1, false));
 100
 101                 propertiesViewer = new TableViewer(bottom);
 102                 propertiesViewer.getTable().setLayoutData(
 103                                 new GridData(SWT.FILL, SWT.FILL, true, true));
 104                 propertiesViewer.getTable().setHeaderVisible(true);
 105                 propertiesViewer.setContentProvider(new PropertiesContentProvider());
 106                 TableViewerColumn col = new TableViewerColumn(propertiesViewer,
 107                                 SWT.NONE);
 108                 col.getColumn().setText("Name");
 109                 col.getColumn().setWidth(200);
 110                 col.setLabelProvider(new ColumnLabelProvider() {
 111                         public String getText(Object element) {
 112                                 try {
 113                                         return ((Property) element).getName();
 114                                 } catch (RepositoryException e) {
 115                                         throw new ArgeoException(
 116                                                         "Unexpected exception in label provider", e);
 117                                 }
 118                         }
 119                 });
 120                 col = new TableViewerColumn(propertiesViewer, SWT.NONE);
 121                 col.getColumn().setText("Value");
 122                 col.getColumn().setWidth(400);
 123                 col.setLabelProvider(new ColumnLabelProvider() {
 124                         public String getText(Object element) {
 125                                 try {
 126                                         Property property = (Property) element;
 127                                         if (property.getType() == PropertyType.BINARY)
 128                                                 return "<binary>";
 129                                         else if (property.isMultiple())
 130                                                 return Arrays.asList(property.getValues()).toString();
 131                                         else
 132                                                 return property.getValue().getString();
 133                                 } catch (RepositoryException e) {
 134                                         throw new ArgeoException(
 135                                                         "Unexpected exception in label provider", e);
 136                                 }
 137                         }
 138                 });
 139                 col = new TableViewerColumn(propertiesViewer, SWT.NONE);
 140                 col.getColumn().setText("Type");
 141                 col.getColumn().setWidth(200);
 142                 col.setLabelProvider(new ColumnLabelProvider() {
 143                         public String getText(Object element) {
 144                                 try {
 145                                         return PropertyType.nameFromValue(((Property) element)
 146                                                         .getType());
 147                                 } catch (RepositoryException e) {
 148                                         throw new ArgeoException(
 149                                                         "Unexpected exception in label provider", e);
 150                                 }
 151                         }
 152                 });
 153                 propertiesViewer.setInput(getViewSite());
 154
 155                 sashForm.setWeights(getWeights());
 156
 157         }
 158
 159         @Override
 160         public void setFocus() {
 161                 nodesViewer.getTree().setFocus();
 162         }
 163
 164         /**
 165          * To be overidden to adapt size of form and result frames.
 166          *
 167          * @return
 168          */
 169         protected int[] getWeights() {
 170                 return new int[] { 70, 30 };
 171         }
 172
 173         public void setJcrSession(Session jcrSession) {
 174                 this.jcrSession = jcrSession;
 175         }
 176
 177         /*
 178          * NODES
 179          */
 180         private class NodeContentProvider implements ITreeContentProvider {
 181
 182                 public Object[] getElements(Object inputElement) {
 183                         return getChildren(inputElement);
 184                 }
 185
 186                 public Object[] getChildren(Object parentElement) {
 187                         try {
 188                                 if (parentElement instanceof Node) {
 189                                         Set<Node> children = new TreeSet<Node>(itemComparator);
 190                                         NodeIterator nit = ((Node) parentElement).getNodes();
 191                                         while (nit.hasNext())
 192                                                 children.add(nit.nextNode());
 193                                         return children.toArray();
 194                                 } else {
 195                                         return null;
 196                                 }
 197                         } catch (RepositoryException e) {
 198                                 throw new ArgeoException("Cannot retrieve children for "
 199                                                 + parentElement, e);
 200                         }
 201                 }
 202
 203                 public Object getParent(Object element) {
 204                         try {
 205                                 if (element instanceof Node) {
 206                                         return ((Node) element).getParent();
 207                                 }
 208                                 return null;
 209                         } catch (RepositoryException e) {
 210                                 throw new ArgeoException(
 211                                                 "Cannot retrieve parent of " + element, e);
 212                         }
 213                 }
 214
 215                 public boolean hasChildren(Object element) {
 216                         try {
 217                                 if (element instanceof Node) {
 218                                         return ((Node) element).hasNodes();
 219                                 }
 220                                 return false;
 221                         } catch (RepositoryException e) {
 222                                 throw new ArgeoException("Cannot check children of " + element,
 223                                                 e);
 224                         }
 225                 }
 226
 227                 public void dispose() {
 228                 }
 229
 230                 public void inputChanged(Viewer viewer, Object oldInput, Object newInput) {
 231                 }
 232
 233         }
 234
 235         class NodeLabelProvider extends LabelProvider {
 236
 237                 public String getText(Object element) {
 238                         try {
 239                                 if (element instanceof Node) {
 240                                         Node node = (Node) element;
 241                                         StringBuffer mixins = new StringBuffer("");
 242                                         for (NodeType type : node.getMixinNodeTypes())
 243                                                 mixins.append(' ').append(type.getName());
 244
 245                                         return node.getName() + " ["
 246                                                         + node.getPrimaryNodeType().getName() + mixins
 247                                                         + "]";
 248                                 }
 249                                 return element.toString();
 250                         } catch (RepositoryException e) {
 251                                 throw new ArgeoException("Cannot get text for of " + element, e);
 252                         }
 253                 }
 254
 255         }
 256
 257         /*
 258          * PROPERTIES
 259          */
 260         private class PropertiesContentProvider implements
 261                         IStructuredContentProvider {
 262
 263                 public void dispose() {
 264                 }
 265
 266                 public void inputChanged(Viewer viewer, Object oldInput, Object newInput) {
 267                 }
 268
 269                 public Object[] getElements(Object inputElement) {
 270                         try {
 271                                 if (inputElement instanceof Node) {
 272                                         Set<Property> props = new TreeSet<Property>(itemComparator);
 273                                         PropertyIterator pit = ((Node) inputElement)
 274                                                         .getProperties();
 275                                         while (pit.hasNext())
 276                                                 props.add(pit.nextProperty());
 277                                         return props.toArray();
 278                                 }
 279                                 return new Object[] {};
 280                         } catch (RepositoryException e) {
 281                                 throw new ArgeoException("Cannot get element for "
 282                                                 + inputElement, e);
 283                         }
 284                 }
 285
 286         }
 287 }