eclipse/plugins/org.argeo.slc.client.ui/src/main/java/org/argeo/slc/client/ui/views/JcrExecutionModulesView.java

   1 package org.argeo.slc.client.ui.views;
   2
   3 import java.util.ArrayList;
   4 import java.util.Arrays;
   5 import java.util.Comparator;
   6 import java.util.List;
   7
   8 import javax.jcr.Node;
   9 import javax.jcr.NodeIterator;
  10 import javax.jcr.Property;
  11 import javax.jcr.RepositoryException;
  12 import javax.jcr.Session;
  13 import javax.jcr.observation.Event;
  14 import javax.jcr.observation.EventIterator;
  15 import javax.jcr.observation.EventListener;
  16
  17 import org.apache.commons.logging.Log;
  18 import org.apache.commons.logging.LogFactory;
  19 import org.argeo.ArgeoException;
  20 import org.argeo.eclipse.ui.jcr.DefaultNodeLabelProvider;
  21 import org.argeo.eclipse.ui.jcr.NodesWrapper;
  22 import org.argeo.eclipse.ui.jcr.SimpleNodeContentProvider;
  23 import org.argeo.eclipse.ui.jcr.WrappedNode;
  24 import org.argeo.slc.SlcException;
  25 import org.argeo.slc.client.ui.SlcImages;
  26 import org.argeo.slc.client.ui.editors.ProcessEditor;
  27 import org.argeo.slc.client.ui.editors.ProcessEditorInput;
  28 import org.argeo.slc.jcr.SlcJcrConstants;
  29 import org.argeo.slc.jcr.SlcNames;
  30 import org.argeo.slc.jcr.SlcTypes;
  31 import org.eclipse.jface.viewers.ColumnViewerToolTipSupport;
  32 import org.eclipse.jface.viewers.DoubleClickEvent;
  33 import org.eclipse.jface.viewers.IDoubleClickListener;
  34 import org.eclipse.jface.viewers.IStructuredSelection;
  35 import org.eclipse.jface.viewers.ITableLabelProvider;
  36 import org.eclipse.jface.viewers.TreeViewer;
  37 import org.eclipse.swt.SWT;
  38 import org.eclipse.swt.dnd.DND;
  39 import org.eclipse.swt.dnd.DragSourceAdapter;
  40 import org.eclipse.swt.dnd.DragSourceEvent;
  41 import org.eclipse.swt.dnd.TextTransfer;
  42 import org.eclipse.swt.dnd.Transfer;
  43 import org.eclipse.swt.graphics.Image;
  44 import org.eclipse.swt.widgets.Composite;
  45 import org.eclipse.ui.IWorkbenchPage;
  46 import org.eclipse.ui.PlatformUI;
  47 import org.eclipse.ui.part.ViewPart;
  48
  49 public class JcrExecutionModulesView extends ViewPart implements SlcTypes,
  50                 SlcNames {
  51         private final static Log log = LogFactory
  52                         .getLog(JcrExecutionModulesView.class);
  53
  54         public static final String ID = "org.argeo.slc.client.ui.jcrExecutionModulesView";
  55
  56         private TreeViewer viewer;
  57
  58         private Session session;
  59
  60         public void createPartControl(Composite parent) {
  61                 viewer = new TreeViewer(parent, SWT.MULTI | SWT.H_SCROLL | SWT.V_SCROLL);
  62                 ColumnViewerToolTipSupport.enableFor(viewer);
  63
  64                 ViewContentProvider contentProvider = new ViewContentProvider(session);
  65
  66                 viewer.setContentProvider(contentProvider);
  67                 final ViewLabelProvider viewLabelProvider = new ViewLabelProvider();
  68                 viewer.setLabelProvider(viewLabelProvider);
  69                 viewer.setInput(getViewSite());
  70                 viewer.addDoubleClickListener(new ViewDoubleClickListener());
  71
  72                 Transfer[] tt = new Transfer[] { TextTransfer.getInstance() };
  73                 // Transfer[] tt = new Transfer[] { EditorInputTransfer.getInstance() };
  74                 int operations = DND.DROP_COPY | DND.DROP_MOVE;
  75                 viewer.addDragSupport(operations, tt, new ViewDragListener());
  76
  77                 try {
  78                         session.getWorkspace()
  79                                         .getObservationManager()
  80                                         .addEventListener(
  81                                                         new VmAgentObserver(),
  82                                                         Event.NODE_ADDED | Event.NODE_REMOVED
  83                                                                         | Event.NODE_MOVED,
  84                                                         SlcJcrConstants.VM_AGENT_FACTORY_PATH, true, null,
  85                                                         null, false);
  86                 } catch (RepositoryException e) {
  87                         throw new SlcException("Cannot add observer", e);
  88                 }
  89         }
  90
  91         public void setFocus() {
  92                 viewer.getControl().setFocus();
  93         }
  94
  95         public TreeViewer getViewer() {
  96                 return viewer;
  97         }
  98
  99         public void refreshView() {
 100                 viewer.setInput(getViewSite());
 101         }
 102
 103         class ViewContentProvider extends SimpleNodeContentProvider {
 104
 105                 public ViewContentProvider(Session session) {
 106                         super(session,
 107                                         new String[] { SlcJcrConstants.VM_AGENT_FACTORY_PATH });
 108                 }
 109
 110                 @Override
 111                 protected Object[] getChildren(Node node) throws RepositoryException {
 112                         if (node.isNodeType(SlcTypes.SLC_AGENT_PROXY)) {
 113                                 List<AgentNodesWrapper> wrappers = new ArrayList<AgentNodesWrapper>();
 114                                 for (NodeIterator nit = node.getNodes(); nit.hasNext();) {
 115                                         wrappers.add(new AgentNodesWrapper(nit.nextNode()));
 116                                 }
 117                                 return wrappers.toArray();
 118                         }
 119                         return super.getChildren(node);
 120                 }
 121
 122                 @Override
 123                 protected Object[] sort(Object parent, Object[] children) {
 124                         Object[] sorted = new Object[children.length];
 125                         System.arraycopy(children, 0, sorted, 0, children.length);
 126                         Arrays.sort(sorted, new ViewComparator());
 127                         return sorted;
 128                 }
 129         }
 130
 131         static class ViewComparator implements Comparator<Object> {
 132
 133                 public int compare(Object o1, Object o2) {
 134                         try {
 135                                 if (o1 instanceof Node && o2 instanceof Node) {
 136                                         Node node1 = (Node) o1;
 137                                         Node node2 = (Node) o2;
 138                                         if (node1.isNodeType(SLC_EXECUTION_FLOW)
 139                                                         && node2.isNodeType(SLC_EXECUTION_FLOW)) {
 140                                                 return node1.getName().compareTo(node2.getName());
 141                                         } else if (node1.isNodeType(SLC_EXECUTION_FLOW)
 142                                                         && !node2.isNodeType(SLC_EXECUTION_FLOW)) {
 143                                                 return 1;
 144                                         } else if (!node1.isNodeType(SLC_EXECUTION_FLOW)
 145                                                         && node2.isNodeType(SLC_EXECUTION_FLOW)) {
 146                                                 return -1;
 147                                         } else {
 148                                                 // TODO: check title
 149                                                 return node1.getName().compareTo(node2.getName());
 150                                         }
 151                                 }
 152                         } catch (RepositoryException e) {
 153                                 throw new ArgeoException("Cannot compare " + o1 + " and " + o2,
 154                                                 e);
 155                         }
 156                         return 0;
 157                 }
 158
 159         }
 160
 161         /** Wraps the execution modules of an agent. */
 162         static class AgentNodesWrapper extends NodesWrapper {
 163
 164                 public AgentNodesWrapper(Node node) {
 165                         super(node);
 166                 }
 167
 168                 protected List<WrappedNode> getWrappedNodes()
 169                                 throws RepositoryException {
 170                         List<WrappedNode> children = new ArrayList<WrappedNode>();
 171                         Node executionModules = getNode().getNode(
 172                                         SlcNames.SLC_EXECUTION_MODULES);
 173                         for (NodeIterator nit = executionModules.getNodes(); nit.hasNext();) {
 174                                 for (NodeIterator nitVersions = nit.nextNode().getNodes(); nitVersions
 175                                                 .hasNext();) {
 176                                         children.add(new WrappedNode(this, nitVersions.nextNode()));
 177                                 }
 178                         }
 179                         return children;
 180                 }
 181
 182         }
 183
 184         class VmAgentObserver implements EventListener {
 185
 186                 public void onEvent(EventIterator events) {
 187                         viewer.refresh();
 188                 }
 189
 190         }
 191
 192         class ViewLabelProvider extends DefaultNodeLabelProvider implements
 193                         ITableLabelProvider {
 194                 public String getColumnText(Object obj, int index) {
 195                         return getText(obj);
 196                 }
 197
 198                 public Image getColumnImage(Object obj, int index) {
 199                         return getImage(obj);
 200                 }
 201
 202                 public Image getImage(Node node) throws RepositoryException {
 203                         if (node.getParent().isNodeType(SlcTypes.SLC_AGENT_PROXY))
 204                                 return SlcImages.AGENT;
 205                         else if (node.isNodeType(SlcTypes.SLC_MODULE))
 206                                 return SlcImages.MODULE;
 207                         else if (node.isNodeType(SlcTypes.SLC_EXECUTION_FLOW))
 208                                 return SlcImages.FLOW;
 209                         else
 210                                 return SlcImages.FOLDER;
 211                 }
 212
 213                 public String getToolTipText(Node node) throws RepositoryException {
 214                         if (node.isNodeType(SlcTypes.SLC_MODULE)
 215                                         && node.hasProperty(Property.JCR_DESCRIPTION))
 216                                 return node.getProperty(Property.JCR_DESCRIPTION).getString();
 217                         return super.getToolTipText(node);
 218                 }
 219
 220         }
 221
 222         class ViewDoubleClickListener implements IDoubleClickListener {
 223                 public void doubleClick(DoubleClickEvent evt) {
 224                         Object obj = ((IStructuredSelection) evt.getSelection())
 225                                         .getFirstElement();
 226                         try {
 227                                 if (obj instanceof Node) {
 228                                         Node node = (Node) obj;
 229                                         if (node.isNodeType(SLC_EXECUTION_FLOW)) {
 230                                                 List<String> paths = new ArrayList<String>();
 231                                                 paths.add(node.getPath());
 232                                                 IWorkbenchPage activePage = PlatformUI.getWorkbench()
 233                                                                 .getActiveWorkbenchWindow().getActivePage();
 234                                                 activePage.openEditor(new ProcessEditorInput(paths,
 235                                                                 true), ProcessEditor.ID);
 236                                         }
 237                                 }
 238                         } catch (Exception e) {
 239                                 throw new SlcException("Cannot open " + obj, e);
 240                         }
 241                 }
 242
 243         }
 244
 245         class ViewDragListener extends DragSourceAdapter {
 246
 247                 public void dragStart(DragSourceEvent event) {
 248                         if (log.isDebugEnabled())
 249                                 log.debug("Start Drag " + event);
 250                         super.dragStart(event);
 251                 }
 252
 253                 public void dragSetData(DragSourceEvent event) {
 254
 255                         // System.out.println("dragSetData: " + event);
 256
 257                         IStructuredSelection selection = (IStructuredSelection) viewer
 258                                         .getSelection();
 259                         if (selection.getFirstElement() instanceof Node) {
 260                                 Node node = (Node) selection.getFirstElement();
 261                                 // try {
 262                                 // if (node.isNodeType(SLC_EXECUTION_FLOW)) {
 263                                 // if (EditorInputTransfer.getInstance().isSupportedType(
 264                                 // event.dataType)) {
 265                                 // ProcessEditorInput pei = new ProcessEditorInput(
 266                                 // node.getPath());
 267                                 // EditorInputData eid = EditorInputTransfer
 268                                 // .createEditorInputData(ProcessEditor.ID,
 269                                 // pei);
 270                                 // event.data = new EditorInputTransfer.EditorInputData[] { eid
 271                                 // };
 272                                 //
 273                                 // }
 274                                 // }
 275                                 // } catch (RepositoryException e1) {
 276                                 // throw new SlcException("Cannot drag " + node, e1);
 277                                 // }
 278
 279                                 if (TextTransfer.getInstance().isSupportedType(event.dataType)) {
 280                                         try {
 281                                                 event.data = node.getPath();
 282                                         } catch (RepositoryException e1) {
 283                                                 // TODO Auto-generated catch block
 284                                                 e1.printStackTrace();
 285                                         }
 286                                 }
 287                         }
 288                 }
 289
 290                 public void dragFinished(DragSourceEvent event) {
 291                         if (log.isDebugEnabled())
 292                                 log.debug("Finished Drag " + event);
 293                 }
 294
 295         }
 296
 297         public void setSession(Session session) {
 298                 this.session = session;
 299         }
 300
 301 }