eclipse/runtime/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.Map;
   8 import java.util.Set;
   9 import java.util.TreeSet;
  10
  11 import javax.jcr.Item;
  12 import javax.jcr.LoginException;
  13 import javax.jcr.Node;
  14 import javax.jcr.NodeIterator;
  15 import javax.jcr.Property;
  16 import javax.jcr.PropertyIterator;
  17 import javax.jcr.PropertyType;
  18 import javax.jcr.Repository;
  19 import javax.jcr.RepositoryException;
  20 import javax.jcr.Session;
  21 import javax.jcr.nodetype.NodeType;
  22
  23 import org.argeo.ArgeoException;
  24 import org.argeo.eclipse.ui.TreeParent;
  25 import org.argeo.jcr.RepositoryRegister;
  26 import org.eclipse.jface.viewers.ColumnLabelProvider;
  27 import org.eclipse.jface.viewers.DoubleClickEvent;
  28 import org.eclipse.jface.viewers.IDoubleClickListener;
  29 import org.eclipse.jface.viewers.ISelectionChangedListener;
  30 import org.eclipse.jface.viewers.IStructuredContentProvider;
  31 import org.eclipse.jface.viewers.IStructuredSelection;
  32 import org.eclipse.jface.viewers.ITreeContentProvider;
  33 import org.eclipse.jface.viewers.LabelProvider;
  34 import org.eclipse.jface.viewers.SelectionChangedEvent;
  35 import org.eclipse.jface.viewers.TableViewer;
  36 import org.eclipse.jface.viewers.TableViewerColumn;
  37 import org.eclipse.jface.viewers.TreeNode;
  38 import org.eclipse.jface.viewers.TreeViewer;
  39 import org.eclipse.jface.viewers.Viewer;
  40 import org.eclipse.swt.SWT;
  41 import org.eclipse.swt.custom.SashForm;
  42 import org.eclipse.swt.layout.FillLayout;
  43 import org.eclipse.swt.layout.GridData;
  44 import org.eclipse.swt.layout.GridLayout;
  45 import org.eclipse.swt.widgets.Composite;
  46 import org.eclipse.ui.part.ViewPart;
  47
  48 public class GenericJcrBrowser extends ViewPart {
  49         // private final static Log log =
  50         // LogFactory.getLog(GenericJcrBrowser.class);
  51
  52         private TreeViewer nodesViewer;
  53         private TableViewer propertiesViewer;
  54
  55         // private Session jcrSession;
  56         private RepositoryRegister repositoryRegister;
  57
  58         private Comparator<Item> itemComparator = new Comparator<Item>() {
  59                 public int compare(Item o1, Item o2) {
  60                         try {
  61                                 return o1.getName().compareTo(o2.getName());
  62                         } catch (RepositoryException e) {
  63                                 throw new ArgeoException("Cannot compare " + o1 + " and " + o2,
  64                                                 e);
  65                         }
  66                 }
  67         };
  68
  69         @Override
  70         public void createPartControl(Composite parent) {
  71                 parent.setLayout(new FillLayout());
  72
  73                 SashForm sashForm = new SashForm(parent, SWT.VERTICAL);
  74                 sashForm.setSashWidth(4);
  75                 sashForm.setLayout(new FillLayout());
  76
  77                 Composite top = new Composite(sashForm, SWT.NONE);
  78                 GridLayout gl = new GridLayout(1, false);
  79                 top.setLayout(gl);
  80
  81                 nodesViewer = new TreeViewer(top, SWT.MULTI | SWT.H_SCROLL
  82                                 | SWT.V_SCROLL);
  83                 nodesViewer.getTree().setLayoutData(
  84                                 new GridData(SWT.FILL, SWT.FILL, true, true));
  85                 nodesViewer.setContentProvider(new NodeContentProvider());
  86                 nodesViewer.setLabelProvider(new NodeLabelProvider());
  87                 nodesViewer
  88                                 .addSelectionChangedListener(new ISelectionChangedListener() {
  89                                         public void selectionChanged(SelectionChangedEvent event) {
  90                                                 if (!event.getSelection().isEmpty()) {
  91                                                         IStructuredSelection sel = (IStructuredSelection) event
  92                                                                         .getSelection();
  93                                                         propertiesViewer.setInput(sel.getFirstElement());
  94                                                 } else {
  95                                                         propertiesViewer.setInput(getViewSite());
  96                                                 }
  97                                         }
  98                                 });
  99                 nodesViewer.addDoubleClickListener(new IDoubleClickListener() {
 100                         public void doubleClick(DoubleClickEvent event) {
 101                                 Object obj = ((IStructuredSelection) event.getSelection())
 102                                                 .getFirstElement();
 103                                 if (obj instanceof RepositoryNode) {
 104                                         ((RepositoryNode) obj).login();
 105                                 } else if (obj instanceof WorkspaceNode) {
 106                                         ((WorkspaceNode) obj).login();
 107                                 }
 108
 109                         }
 110                 });
 111                 nodesViewer.setInput(repositoryRegister);
 112
 113                 Composite bottom = new Composite(sashForm, SWT.NONE);
 114                 bottom.setLayout(new GridLayout(1, false));
 115
 116                 propertiesViewer = new TableViewer(bottom);
 117                 propertiesViewer.getTable().setLayoutData(
 118                                 new GridData(SWT.FILL, SWT.FILL, true, true));
 119                 propertiesViewer.getTable().setHeaderVisible(true);
 120                 propertiesViewer.setContentProvider(new PropertiesContentProvider());
 121                 TableViewerColumn col = new TableViewerColumn(propertiesViewer,
 122                                 SWT.NONE);
 123                 col.getColumn().setText("Name");
 124                 col.getColumn().setWidth(200);
 125                 col.setLabelProvider(new ColumnLabelProvider() {
 126                         public String getText(Object element) {
 127                                 try {
 128                                         return ((Property) element).getName();
 129                                 } catch (RepositoryException e) {
 130                                         throw new ArgeoException(
 131                                                         "Unexpected exception in label provider", e);
 132                                 }
 133                         }
 134                 });
 135                 col = new TableViewerColumn(propertiesViewer, SWT.NONE);
 136                 col.getColumn().setText("Value");
 137                 col.getColumn().setWidth(400);
 138                 col.setLabelProvider(new ColumnLabelProvider() {
 139                         public String getText(Object element) {
 140                                 try {
 141                                         Property property = (Property) element;
 142                                         if (property.getType() == PropertyType.BINARY)
 143                                                 return "<binary>";
 144                                         else if (property.isMultiple())
 145                                                 return Arrays.asList(property.getValues()).toString();
 146                                         else
 147                                                 return property.getValue().getString();
 148                                 } catch (RepositoryException e) {
 149                                         throw new ArgeoException(
 150                                                         "Unexpected exception in label provider", e);
 151                                 }
 152                         }
 153                 });
 154                 col = new TableViewerColumn(propertiesViewer, SWT.NONE);
 155                 col.getColumn().setText("Type");
 156                 col.getColumn().setWidth(200);
 157                 col.setLabelProvider(new ColumnLabelProvider() {
 158                         public String getText(Object element) {
 159                                 try {
 160                                         return PropertyType.nameFromValue(((Property) element)
 161                                                         .getType());
 162                                 } catch (RepositoryException e) {
 163                                         throw new ArgeoException(
 164                                                         "Unexpected exception in label provider", e);
 165                                 }
 166                         }
 167                 });
 168                 propertiesViewer.setInput(getViewSite());
 169
 170                 sashForm.setWeights(getWeights());
 171
 172         }
 173
 174         @Override
 175         public void setFocus() {
 176                 nodesViewer.getTree().setFocus();
 177         }
 178
 179         /**
 180          * To be overidden to adapt size of form and result frames.
 181          *
 182          * @return
 183          */
 184         protected int[] getWeights() {
 185                 return new int[] { 70, 30 };
 186         }
 187
 188         public void setRepositoryRegister(RepositoryRegister repositoryRegister) {
 189                 this.repositoryRegister = repositoryRegister;
 190         }
 191
 192         /*
 193          * NODES
 194          */
 195         protected Object[] childrenNodes(Node parentNode) {
 196                 try {
 197                         List<Node> children = new ArrayList<Node>();
 198                         NodeIterator nit = parentNode.getNodes();
 199                         while (nit.hasNext()) {
 200                                 Node node = nit.nextNode();
 201                                 children.add(node);
 202                         }
 203                         Node[] arr = children.toArray(new Node[children.size()]);
 204                         Arrays.sort(arr, itemComparator);
 205                         return arr;
 206                 } catch (RepositoryException e) {
 207                         throw new ArgeoException("Cannot list children of " + parentNode, e);
 208                 }
 209         }
 210
 211         private class NodeContentProvider implements ITreeContentProvider {
 212
 213                 public Object[] getElements(Object inputElement) {
 214                         return getChildren(inputElement);
 215                 }
 216
 217                 public Object[] getChildren(Object parentElement) {
 218                         if (parentElement instanceof Node) {
 219                                 return childrenNodes((Node) parentElement);
 220                         } else if (parentElement instanceof RepositoryNode) {
 221                                 return ((RepositoryNode) parentElement).getChildren();
 222                         } else if (parentElement instanceof WorkspaceNode) {
 223                                 Session session = ((WorkspaceNode) parentElement).getSession();
 224                                 if (session == null)
 225                                         return new Object[0];
 226
 227                                 try {
 228                                         return childrenNodes(session.getRootNode());
 229                                 } catch (RepositoryException e) {
 230                                         throw new ArgeoException("Cannot retrieve root node of "
 231                                                         + session, e);
 232                                 }
 233                         } else if (parentElement instanceof RepositoryRegister) {
 234                                 RepositoryRegister repositoryRegister = (RepositoryRegister) parentElement;
 235                                 List<RepositoryNode> nodes = new ArrayList<RepositoryNode>();
 236                                 Map<String, Repository> repositories = repositoryRegister
 237                                                 .getRepositories();
 238                                 for (String name : repositories.keySet()) {
 239                                         nodes.add(new RepositoryNode(name, repositories.get(name)));
 240                                 }
 241                                 return nodes.toArray();
 242                         } else {
 243                                 return new Object[0];
 244                         }
 245                 }
 246
 247                 public Object getParent(Object element) {
 248                         try {
 249                                 if (element instanceof Node) {
 250                                         return ((Node) element).getParent();
 251                                 }
 252                                 return null;
 253                         } catch (RepositoryException e) {
 254                                 throw new ArgeoException(
 255                                                 "Cannot retrieve parent of " + element, e);
 256                         }
 257                 }
 258
 259                 public boolean hasChildren(Object element) {
 260                         try {
 261                                 if (element instanceof Node) {
 262                                         return ((Node) element).hasNodes();
 263                                 } else if (element instanceof RepositoryNode) {
 264                                         return ((RepositoryNode) element).hasChildren();
 265                                 } else if (element instanceof WorkspaceNode) {
 266                                         return ((WorkspaceNode) element).getSession() != null;
 267                                 }
 268                                 return false;
 269                         } catch (RepositoryException e) {
 270                                 throw new ArgeoException("Cannot check children of " + element,
 271                                                 e);
 272                         }
 273                 }
 274
 275                 public void dispose() {
 276                 }
 277
 278                 public void inputChanged(Viewer viewer, Object oldInput, Object newInput) {
 279                 }
 280
 281         }
 282
 283         class NodeLabelProvider extends LabelProvider {
 284
 285                 public String getText(Object element) {
 286                         try {
 287                                 if (element instanceof Node) {
 288                                         Node node = (Node) element;
 289                                         String label = node.getName();
 290                                         // try {
 291                                         // Item primaryItem = node.getPrimaryItem();
 292                                         // label = primaryItem instanceof Property ? ((Property)
 293                                         // primaryItem)
 294                                         // .getValue().getString()
 295                                         // + " ("
 296                                         // + node.getName()
 297                                         // + ")" : node.getName();
 298                                         // } catch (RepositoryException e) {
 299                                         // label = node.getName();
 300                                         // }
 301                                         StringBuffer mixins = new StringBuffer("");
 302                                         for (NodeType type : node.getMixinNodeTypes())
 303                                                 mixins.append(' ').append(type.getName());
 304
 305                                         return label + " [" + node.getPrimaryNodeType().getName()
 306                                                         + mixins + "]";
 307                                 }
 308                                 return element.toString();
 309                         } catch (RepositoryException e) {
 310                                 throw new ArgeoException("Cannot get text for of " + element, e);
 311                         }
 312                 }
 313
 314         }
 315
 316         /*
 317          * PROPERTIES
 318          */
 319         private class PropertiesContentProvider implements
 320                         IStructuredContentProvider {
 321
 322                 public void dispose() {
 323                 }
 324
 325                 public void inputChanged(Viewer viewer, Object oldInput, Object newInput) {
 326                 }
 327
 328                 public Object[] getElements(Object inputElement) {
 329                         try {
 330                                 if (inputElement instanceof Node) {
 331                                         Set<Property> props = new TreeSet<Property>(itemComparator);
 332                                         PropertyIterator pit = ((Node) inputElement)
 333                                                         .getProperties();
 334                                         while (pit.hasNext())
 335                                                 props.add(pit.nextProperty());
 336                                         return props.toArray();
 337                                 }
 338                                 return new Object[] {};
 339                         } catch (RepositoryException e) {
 340                                 throw new ArgeoException("Cannot get element for "
 341                                                 + inputElement, e);
 342                         }
 343                 }
 344
 345         }
 346
 347         private class RepositoryNode extends TreeParent {
 348                 private final String name;
 349                 private final Repository repository;
 350                 private Session defaultSession = null;
 351
 352                 public RepositoryNode(String name, Repository repository) {
 353                         super(name);
 354                         this.name = name;
 355                         this.repository = repository;
 356                 }
 357
 358                 public Repository getRepository() {
 359                         return repository;
 360                 }
 361
 362                 public Session getDefaultSession() {
 363                         return defaultSession;
 364                 }
 365
 366                 public void login() {
 367                         try {
 368                                 defaultSession = repository.login();
 369                                 String[] wkpNames = defaultSession.getWorkspace()
 370                                                 .getAccessibleWorkspaceNames();
 371                                 for (String wkpName : wkpNames) {
 372                                         if (wkpName.equals(defaultSession.getWorkspace().getName()))
 373                                                 addChild(new WorkspaceNode(repository, wkpName,
 374                                                                 defaultSession));
 375                                         else
 376                                                 addChild(new WorkspaceNode(repository, wkpName));
 377                                 }
 378                                 nodesViewer.refresh(this);
 379                         } catch (RepositoryException e) {
 380                                 throw new ArgeoException(
 381                                                 "Cannot connect to repository " + name, e);
 382                         }
 383                 }
 384         }
 385
 386         private class WorkspaceNode extends TreeParent {
 387                 private final String name;
 388                 private final Repository repository;
 389                 private Session session = null;
 390
 391                 public WorkspaceNode(Repository repository, String name) {
 392                         this(repository, name, null);
 393                 }
 394
 395                 public WorkspaceNode(Repository repository, String name, Session session) {
 396                         super(name);
 397                         this.name = name;
 398                         this.repository = repository;
 399                         this.session = session;
 400                 }
 401
 402                 public Session getSession() {
 403                         return session;
 404                 }
 405
 406                 public void login() {
 407                         try {
 408                                 if (session != null)
 409                                         session.logout();
 410
 411                                 session = repository.login(name);
 412                                 nodesViewer.refresh(this);
 413                         } catch (RepositoryException e) {
 414                                 throw new ArgeoException(
 415                                                 "Cannot connect to repository " + name, e);
 416                         }
 417                 }
 418
 419         }
 420 }