views/GenericJcrBrowser.java

   1 package org.argeo.jcr.ui.explorer.views;
   2
   3 import java.util.Arrays;
   4 import java.util.List;
   5
   6 import javax.jcr.Property;
   7 import javax.jcr.PropertyType;
   8 import javax.jcr.Repository;
   9 import javax.jcr.RepositoryException;
  10 import javax.jcr.Session;
  11 import javax.jcr.observation.Event;
  12 import javax.jcr.observation.EventListener;
  13 import javax.jcr.observation.ObservationManager;
  14
  15 import org.apache.commons.logging.Log;
  16 import org.apache.commons.logging.LogFactory;
  17 import org.argeo.ArgeoException;
  18 import org.argeo.eclipse.ui.jcr.AsyncUiEventListener;
  19 import org.argeo.eclipse.ui.jcr.utils.NodeViewerComparer;
  20 import org.argeo.eclipse.ui.jcr.views.AbstractJcrBrowser;
  21 import org.argeo.eclipse.ui.specific.FileHandler;
  22 import org.argeo.jcr.ArgeoJcrConstants;
  23 import org.argeo.jcr.JcrUtils;
  24 import org.argeo.jcr.RepositoryRegister;
  25 import org.argeo.jcr.ui.explorer.browser.NodeContentProvider;
  26 import org.argeo.jcr.ui.explorer.browser.NodeLabelProvider;
  27 import org.argeo.jcr.ui.explorer.browser.PropertiesContentProvider;
  28 import org.argeo.jcr.ui.explorer.utils.GenericNodeDoubleClickListener;
  29 import org.argeo.jcr.ui.explorer.utils.JcrFileProvider;
  30 import org.eclipse.jface.action.MenuManager;
  31 import org.eclipse.jface.viewers.ColumnLabelProvider;
  32 import org.eclipse.jface.viewers.ISelectionChangedListener;
  33 import org.eclipse.jface.viewers.IStructuredSelection;
  34 import org.eclipse.jface.viewers.ITreeContentProvider;
  35 import org.eclipse.jface.viewers.SelectionChangedEvent;
  36 import org.eclipse.jface.viewers.TableViewer;
  37 import org.eclipse.jface.viewers.TableViewerColumn;
  38 import org.eclipse.jface.viewers.TreeViewer;
  39 import org.eclipse.swt.SWT;
  40 import org.eclipse.swt.custom.SashForm;
  41 import org.eclipse.swt.layout.FillLayout;
  42 import org.eclipse.swt.layout.GridData;
  43 import org.eclipse.swt.layout.GridLayout;
  44 import org.eclipse.swt.widgets.Composite;
  45 import org.eclipse.swt.widgets.Display;
  46 import org.eclipse.swt.widgets.Menu;
  47
  48 /**
  49  * Basic View to display a sash form to browse a JCR compliant multirepository
  50  * environment
  51  */
  52
  53 public class GenericJcrBrowser extends AbstractJcrBrowser {
  54         private final static Log log = LogFactory.getLog(GenericJcrBrowser.class);
  55
  56         /* DEPENDENCY INJECTION */
  57         private Session session;
  58         private RepositoryRegister repositoryRegister;
  59
  60         // This page widgets
  61         private TreeViewer nodesViewer;
  62         private NodeContentProvider nodeContentProvider;
  63         private TableViewer propertiesViewer;
  64         private EventListener resultsObserver;
  65
  66         // Manage documents
  67         private JcrFileProvider jcrFileProvider;
  68         private FileHandler fileHandler;
  69
  70         @Override
  71         public void createPartControl(Composite parent) {
  72
  73                 // look for session
  74                 Session nodeSession = session;
  75                 if (nodeSession == null) {
  76                         Repository nodeRepository = JcrUtils.getRepositoryByAlias(
  77                                         repositoryRegister, ArgeoJcrConstants.ALIAS_NODE);
  78                         if (nodeRepository != null)
  79                                 try {
  80                                         nodeSession = nodeRepository.login();
  81                                         // TODO : enhance that to enable multirepository listener.
  82                                         session = nodeSession;
  83                                 } catch (RepositoryException e1) {
  84                                         throw new ArgeoException("Cannot login to node repository");
  85                                 }
  86                 }
  87
  88                 // Instantiate the generic object that fits for
  89                 // both RCP & RAP
  90                 // Note that in RAP, it registers a service handler that provide the
  91                 // access to the files.
  92                 jcrFileProvider = new JcrFileProvider();
  93                 fileHandler = new FileHandler(jcrFileProvider);
  94
  95                 parent.setLayout(new FillLayout());
  96                 SashForm sashForm = new SashForm(parent, SWT.VERTICAL);
  97                 sashForm.setSashWidth(4);
  98                 sashForm.setLayout(new FillLayout());
  99
 100                 // Create the tree on top of the view
 101                 Composite top = new Composite(sashForm, SWT.NONE);
 102                 GridLayout gl = new GridLayout(1, false);
 103                 top.setLayout(gl);
 104
 105                 nodeContentProvider = new NodeContentProvider(nodeSession,
 106                                 repositoryRegister);
 107
 108                 // nodes viewer
 109                 nodesViewer = createNodeViewer(top, nodeContentProvider);
 110
 111                 // context menu
 112                 MenuManager menuManager = new MenuManager();
 113                 Menu menu = menuManager.createContextMenu(nodesViewer.getTree());
 114                 nodesViewer.getTree().setMenu(menu);
 115                 getSite().registerContextMenu(menuManager, nodesViewer);
 116                 getSite().setSelectionProvider(nodesViewer);
 117
 118                 nodesViewer.setInput(getViewSite());
 119
 120                 // Create the property viewer on the bottom
 121                 Composite bottom = new Composite(sashForm, SWT.NONE);
 122                 bottom.setLayout(new GridLayout(1, false));
 123                 propertiesViewer = new TableViewer(bottom);
 124                 propertiesViewer.getTable().setLayoutData(
 125                                 new GridData(SWT.FILL, SWT.FILL, true, true));
 126                 propertiesViewer.getTable().setHeaderVisible(true);
 127                 propertiesViewer.setContentProvider(new PropertiesContentProvider());
 128                 TableViewerColumn col = new TableViewerColumn(propertiesViewer,
 129                                 SWT.NONE);
 130                 col.getColumn().setText("Name");
 131                 col.getColumn().setWidth(200);
 132                 col.setLabelProvider(new ColumnLabelProvider() {
 133                         public String getText(Object element) {
 134                                 try {
 135                                         return ((Property) element).getName();
 136                                 } catch (RepositoryException e) {
 137                                         throw new ArgeoException(
 138                                                         "Unexpected exception in label provider", e);
 139                                 }
 140                         }
 141                 });
 142                 col = new TableViewerColumn(propertiesViewer, SWT.NONE);
 143                 col.getColumn().setText("Value");
 144                 col.getColumn().setWidth(400);
 145                 col.setLabelProvider(new ColumnLabelProvider() {
 146                         public String getText(Object element) {
 147                                 try {
 148                                         Property property = (Property) element;
 149                                         if (property.getType() == PropertyType.BINARY)
 150                                                 return "<binary>";
 151                                         else if (property.isMultiple())
 152                                                 return Arrays.asList(property.getValues()).toString();
 153                                         else
 154                                                 return property.getValue().getString();
 155                                 } catch (RepositoryException e) {
 156                                         throw new ArgeoException(
 157                                                         "Unexpected exception in label provider", e);
 158                                 }
 159                         }
 160                 });
 161                 col = new TableViewerColumn(propertiesViewer, SWT.NONE);
 162                 col.getColumn().setText("Type");
 163                 col.getColumn().setWidth(200);
 164                 col.setLabelProvider(new ColumnLabelProvider() {
 165                         public String getText(Object element) {
 166                                 try {
 167                                         return PropertyType.nameFromValue(((Property) element)
 168                                                         .getType());
 169                                 } catch (RepositoryException e) {
 170                                         throw new ArgeoException(
 171                                                         "Unexpected exception in label provider", e);
 172                                 }
 173                         }
 174                 });
 175                 propertiesViewer.setInput(getViewSite());
 176
 177                 sashForm.setWeights(getWeights());
 178                 nodesViewer.setComparer(new NodeViewerComparer());
 179         }
 180
 181         /**
 182          * To be overridden to adapt size of form and result frames.
 183          */
 184         protected int[] getWeights() {
 185                 return new int[] { 70, 30 };
 186         }
 187
 188         // @Override
 189         // public void setFocus() {
 190         // nodesViewer.getTree().setFocus();
 191         // }
 192         //
 193         // /*
 194         // * NOTIFICATION
 195         // */
 196         // public void refresh(Object obj) {
 197         // nodesViewer.refresh(obj);
 198         // }
 199         //
 200         // public void nodeAdded(Node parentNode, Node newNode) {
 201         // nodesViewer.refresh(parentNode);
 202         // nodesViewer.expandToLevel(newNode, 0);
 203         // }
 204         //
 205         // public void nodeRemoved(Node parentNode) {
 206         //
 207         // IStructuredSelection newSel = new StructuredSelection(parentNode);
 208         // nodesViewer.setSelection(newSel, true);
 209         // // Force refresh
 210         // IStructuredSelection tmpSel = (IStructuredSelection) nodesViewer
 211         // .getSelection();
 212         // nodesViewer.refresh(tmpSel.getFirstElement());
 213         // }
 214
 215         private JcrFileProvider getJcrFileProvider() {
 216                 return jcrFileProvider;
 217         }
 218
 219         private FileHandler getFileHandler() {
 220                 return fileHandler;
 221         }
 222
 223         protected TreeViewer createNodeViewer(Composite parent,
 224                         final ITreeContentProvider nodeContentProvider) {
 225
 226                 final TreeViewer tmpNodeViewer = new TreeViewer(parent, SWT.MULTI);
 227
 228                 tmpNodeViewer.getTree().setLayoutData(
 229                                 new GridData(SWT.FILL, SWT.FILL, true, true));
 230
 231                 tmpNodeViewer.setContentProvider(nodeContentProvider);
 232                 tmpNodeViewer.setLabelProvider(new NodeLabelProvider());
 233                 tmpNodeViewer
 234                                 .addSelectionChangedListener(new ISelectionChangedListener() {
 235                                         public void selectionChanged(SelectionChangedEvent event) {
 236                                                 if (!event.getSelection().isEmpty()) {
 237                                                         IStructuredSelection sel = (IStructuredSelection) event
 238                                                                         .getSelection();
 239                                                         propertiesViewer.setInput(sel.getFirstElement());
 240                                                 } else {
 241                                                         propertiesViewer.setInput(getViewSite());
 242                                                 }
 243                                         }
 244                                 });
 245
 246                 resultsObserver = new TreeObserver(tmpNodeViewer.getTree().getDisplay());
 247                 try {
 248                         ObservationManager observationManager = session.getWorkspace()
 249                                         .getObservationManager();
 250                         observationManager.addEventListener(resultsObserver,
 251                                         Event.PROPERTY_ADDED | Event.PROPERTY_CHANGED, "/", true,
 252                                         null, null, false);
 253                 } catch (RepositoryException e) {
 254                         throw new ArgeoException("Cannot register listeners", e);
 255                 }
 256
 257                 tmpNodeViewer
 258                                 .addDoubleClickListener(new GenericNodeDoubleClickListener(
 259                                                 tmpNodeViewer));
 260                 return tmpNodeViewer;
 261         }
 262
 263         @Override
 264         protected TreeViewer getNodeViewer() {
 265                 return nodesViewer;
 266         }
 267
 268         class TreeObserver extends AsyncUiEventListener {
 269
 270                 public TreeObserver(Display display) {
 271                         super(display);
 272                 }
 273
 274                 @Override
 275                 protected Boolean willProcessInUiThread(List<Event> events)
 276                                 throws RepositoryException {
 277                         for (Event event : events) {
 278                                 if (getLog().isTraceEnabled())
 279                                         getLog().debug("Received event " + event);
 280                                 String path = event.getPath();
 281                                 int index = path.lastIndexOf('/');
 282                                 String propertyName = path.substring(index + 1);
 283                                 if (getLog().isTraceEnabled())
 284                                         getLog().debug("Concerned property " + propertyName);
 285                         }
 286                         return false;
 287                 }
 288
 289                 protected void onEventInUiThread(List<Event> events)
 290                                 throws RepositoryException {
 291                         if (getLog().isTraceEnabled())
 292                                 getLog().trace("Refresh result list");
 293                         nodesViewer.refresh();
 294                 }
 295
 296         }
 297
 298         /* DEPENDENCY INJECTION */
 299         public void setRepositoryRegister(RepositoryRegister repositoryRegister) {
 300                 this.repositoryRegister = repositoryRegister;
 301         }
 302
 303         public void setSession(Session session) {
 304                 this.session = session;
 305         }
 306
 307 }