From: Bruno Sinou <bsinou@argeo.org>
Date: Wed, 22 Aug 2012 14:49:15 +0000 (+0000)
Subject: introduce a new view to display JcrResults has a tree.
X-Git-Tag: argeo-slc-2.1.7~638
X-Git-Url: http://git.argeo.org/?a=commitdiff_plain;h=e8997305e4d5fe939e2e4ec55195afdc0d488bbc;p=gpl%2Fargeo-slc.git

introduce a new view to display JcrResults has a tree.

git-svn-id: https://svn.argeo.org/slc/trunk@5533 4cfe0d0a-d680-48aa-b62c-e0a02a3f76cc
---

diff --git a/plugins/org.argeo.slc.client.ui/plugin.xml b/plugins/org.argeo.slc.client.ui/plugin.xml
index bd423323b..7ee6be7aa 100644
--- a/plugins/org.argeo.slc.client.ui/plugin.xml
+++ b/plugins/org.argeo.slc.client.ui/plugin.xml
@@ -89,6 +89,22 @@
 	        id="org.argeo.slc.client.ui.updateModule"
 	    	name="Update Module">
 	    </command>
+	    
+	    <!-- Commands that do not need dependency injection --> 
+	    <command
+	        defaultHandler="org.argeo.slc.client.ui.commands.AddResultFolder"
+	        id="org.argeo.slc.client.ui.addResultFolder"
+	    	name="Add result folder">
+	    </command>
+	    <command
+	        defaultHandler="org.argeo.slc.client.ui.commands.RefreshJcrResultTreeView"
+	        id="org.argeo.slc.client.ui.refreshJcrResultTreeView"
+	    	name="Refresh">
+	    	<commandParameter
+         		id="org.argeo.slc.client.ui.param.refreshType"
+         		name="Refresh type">
+  	 		</commandParameter>
+	    </command>
 	    <!--
 		<command
 	        defaultHandler="org.argeo.eclipse.spring.SpringCommandHandler"
diff --git a/plugins/org.argeo.slc.client.ui/src/main/java/org/argeo/slc/client/ui/SlcUiConstants.java b/plugins/org.argeo.slc.client.ui/src/main/java/org/argeo/slc/client/ui/SlcUiConstants.java
new file mode 100644
index 000000000..073c16e55
--- /dev/null
+++ b/plugins/org.argeo.slc.client.ui/src/main/java/org/argeo/slc/client/ui/SlcUiConstants.java
@@ -0,0 +1,26 @@
+/*
+ * Copyright (C) 2007-2012 Mathieu Baudier
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *         http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+package org.argeo.slc.client.ui;
+
+/** SLC UI common constants */
+public interface SlcUiConstants {
+
+	/*
+	 * MISCEALLENEOUS
+	 */
+	public final static String DEFAULT_DISPLAY_DATE_FORMAT = "MM/dd/yy";
+	public final static String DEFAULT_DISPLAY_DATE_TIME_FORMAT = "MM/dd/yyyy, HH:mm:ss";
+}
diff --git a/plugins/org.argeo.slc.client.ui/src/main/java/org/argeo/slc/client/ui/commands/AddResultFolder.java b/plugins/org.argeo.slc.client.ui/src/main/java/org/argeo/slc/client/ui/commands/AddResultFolder.java
new file mode 100644
index 000000000..e1b357482
--- /dev/null
+++ b/plugins/org.argeo.slc.client.ui/src/main/java/org/argeo/slc/client/ui/commands/AddResultFolder.java
@@ -0,0 +1,73 @@
+/*
+ * Copyright (C) 2007-2012 Mathieu Baudier
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *         http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+package org.argeo.slc.client.ui.commands;
+
+import javax.jcr.Node;
+import javax.jcr.RepositoryException;
+
+import org.argeo.eclipse.ui.ErrorFeedback;
+import org.argeo.eclipse.ui.dialogs.SingleValue;
+import org.argeo.slc.SlcException;
+import org.argeo.slc.client.ui.ClientUiPlugin;
+import org.argeo.slc.client.ui.model.ResultFolder;
+import org.argeo.slc.jcr.SlcJcrResultUtils;
+import org.eclipse.core.commands.AbstractHandler;
+import org.eclipse.core.commands.ExecutionEvent;
+import org.eclipse.core.commands.ExecutionException;
+import org.eclipse.jface.viewers.IStructuredSelection;
+import org.eclipse.ui.handlers.HandlerUtil;
+
+/**
+ * Add a new SlcType.SLC_RESULT_FOLDER node to the current user "my result"
+ * tree. This handler is only intended to bu used with JcrResultTreeView and its
+ * descendants.
+ */
+
+public class AddResultFolder extends AbstractHandler {
+	public final static String ID = ClientUiPlugin.ID + ".addResultFolder";
+	public final static String DEFAULT_ICON_REL_PATH = "icons/addFolder.gif";
+	public final static String DEFAULT_LABEL = "New result folder";
+
+	public Object execute(ExecutionEvent event) throws ExecutionException {
+		IStructuredSelection selection = (IStructuredSelection) HandlerUtil
+				.getActiveWorkbenchWindow(event).getActivePage().getSelection();
+
+		// Sanity check, already done when populating the corresponding popup
+		// menu.
+		if (selection != null && selection.size() == 1
+				&& selection.getFirstElement() instanceof ResultFolder) {
+			ResultFolder rf = (ResultFolder) selection.getFirstElement();
+			try {
+				String folderName = SingleValue.ask("Folder name",
+						"Enter folder name");
+				if (folderName != null) {
+					Node parentNode = rf.getNode();
+					String absPath = parentNode.getPath()+ "/"
+							+ folderName;
+					SlcJcrResultUtils.createResultFolderNode(
+							parentNode.getSession(), absPath);
+				}
+			} catch (RepositoryException e) {
+				throw new SlcException(
+						"Unexpected exception while creating result folder", e);
+			}
+		} else {
+			ErrorFeedback.show("Can only add file folder to a node");
+		}
+		return null;
+	}
+}
\ No newline at end of file
diff --git a/plugins/org.argeo.slc.client.ui/src/main/java/org/argeo/slc/client/ui/commands/DeleteResult.java b/plugins/org.argeo.slc.client.ui/src/main/java/org/argeo/slc/client/ui/commands/DeleteResult.java
new file mode 100644
index 000000000..321a6b552
--- /dev/null
+++ b/plugins/org.argeo.slc.client.ui/src/main/java/org/argeo/slc/client/ui/commands/DeleteResult.java
@@ -0,0 +1,109 @@
+/*
+ * Copyright (C) 2007-2012 Mathieu Baudier
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *         http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+package org.argeo.slc.client.ui.commands;
+
+import java.util.ArrayList;
+import java.util.Iterator;
+import java.util.List;
+
+import javax.jcr.Node;
+import javax.jcr.RepositoryException;
+import javax.jcr.Session;
+
+import org.argeo.eclipse.ui.ErrorFeedback;
+import org.argeo.slc.client.ui.model.ResultFolder;
+import org.argeo.slc.client.ui.model.SingleResultNode;
+import org.eclipse.core.commands.AbstractHandler;
+import org.eclipse.core.commands.ExecutionEvent;
+import org.eclipse.core.commands.ExecutionException;
+import org.eclipse.core.runtime.IProgressMonitor;
+import org.eclipse.core.runtime.IStatus;
+import org.eclipse.core.runtime.Status;
+import org.eclipse.core.runtime.jobs.Job;
+import org.eclipse.jface.dialogs.MessageDialog;
+import org.eclipse.jface.viewers.ISelection;
+import org.eclipse.jface.viewers.IStructuredSelection;
+import org.eclipse.ui.handlers.HandlerUtil;
+
+/** Deletes one or many results */
+public class DeleteResult extends AbstractHandler {
+	/* DEPENDENCY INJECTION */
+	private Session session;
+
+	public Object execute(final ExecutionEvent event) throws ExecutionException {
+		final ISelection selection = HandlerUtil
+				.getActiveWorkbenchWindow(event).getActivePage().getSelection();
+
+		if (!MessageDialog.openConfirm(HandlerUtil.getActiveShell(event),
+				"Confirm",
+				"Are you sure that you want to delete these results?"))
+			return null;
+
+		Job job = new Job("Delete results") {
+			@Override
+			protected IStatus run(IProgressMonitor monitor) {
+				if (selection != null
+						&& selection instanceof IStructuredSelection) {
+					List<String> nodes = new ArrayList<String>();
+					Iterator<?> it = ((IStructuredSelection) selection)
+							.iterator();
+					Object obj = null;
+					try {
+						while (it.hasNext()) {
+							obj = it.next();
+							if (obj instanceof ResultFolder) {
+								Node node = ((ResultFolder) obj).getNode();
+								nodes.add(node.getPath());
+							} else if (obj instanceof SingleResultNode) {
+								Node node = ((SingleResultNode) obj).getNode();
+								nodes.add(node.getPath());
+							}
+						}
+					} catch (RepositoryException e) {
+						ErrorFeedback.show("Cannot list nodes", e);
+						return null;
+					}
+					monitor.beginTask("Delete results", nodes.size());
+					Node node = null;
+					try {
+						for (final String path : nodes) {
+							if (session.itemExists(path)) {
+								node = session.getNode(path);
+								node.remove();
+							}
+							monitor.worked(1);
+						}
+						session.save();
+					} catch (RepositoryException e) {
+						ErrorFeedback.show("Cannot delete node " + node, e);
+					}
+					monitor.done();
+				}
+				return Status.OK_STATUS;
+			}
+
+		};
+		job.setUser(true);
+		job.schedule();
+		return null;
+	}
+
+	/* DEPENDENCY INJECTION */
+	public void setSession(Session session) {
+		this.session = session;
+	}
+}
diff --git a/plugins/org.argeo.slc.client.ui/src/main/java/org/argeo/slc/client/ui/commands/RefreshJcrResultTreeView.java b/plugins/org.argeo.slc.client.ui/src/main/java/org/argeo/slc/client/ui/commands/RefreshJcrResultTreeView.java
new file mode 100644
index 000000000..9661775b8
--- /dev/null
+++ b/plugins/org.argeo.slc.client.ui/src/main/java/org/argeo/slc/client/ui/commands/RefreshJcrResultTreeView.java
@@ -0,0 +1,66 @@
+package org.argeo.slc.client.ui.commands;
+
+/*
+ * Copyright (C) 2007-2012 Mathieu Baudier
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *         http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+import java.util.Iterator;
+
+import org.argeo.slc.client.ui.ClientUiPlugin;
+import org.argeo.slc.client.ui.model.ResultParent;
+import org.argeo.slc.client.ui.views.JcrResultTreeView;
+import org.eclipse.core.commands.AbstractHandler;
+import org.eclipse.core.commands.ExecutionEvent;
+import org.eclipse.core.commands.ExecutionException;
+import org.eclipse.jface.viewers.IStructuredSelection;
+import org.eclipse.ui.handlers.HandlerUtil;
+
+/**
+ * Force refresh the ResultTreeView. This command is only intended to be called
+ * by either the toolbar menu of the view or by the popup menu. Refresh due to
+ * data changes must be triggered by Observers
+ */
+public class RefreshJcrResultTreeView extends AbstractHandler {
+	public final static String ID = ClientUiPlugin.ID
+			+ ".refreshJcrResultTreeView";
+	public final static String PARAM_REFRESH_TYPE = ClientUiPlugin.ID
+			+ ".param.refreshType";
+	public final static String PARAM_REFRESH_TYPE_FULL = "fullRefresh";
+
+	public Object execute(final ExecutionEvent event) throws ExecutionException {
+		String refreshType = event.getParameter(PARAM_REFRESH_TYPE);
+		JcrResultTreeView view = (JcrResultTreeView) HandlerUtil
+				.getActiveWorkbenchWindow(event).getActivePage()
+				.getActivePart();
+
+		// force full refresh without preserving selection from the tool bar
+		if (PARAM_REFRESH_TYPE_FULL.equals(refreshType))
+			view.refresh(null);
+		else {
+			IStructuredSelection selection = (IStructuredSelection) HandlerUtil
+					.getActiveWorkbenchWindow(event).getActivePage()
+					.getSelection();
+			@SuppressWarnings("rawtypes")
+			Iterator it = selection.iterator();
+			while (it.hasNext()) {
+				Object obj = it.next();
+				if (obj instanceof ResultParent) {
+					view.refresh((ResultParent) obj);
+				}
+			}
+		}
+		return null;
+	}
+}
diff --git a/plugins/org.argeo.slc.client.ui/src/main/java/org/argeo/slc/client/ui/commands/RunSlcFlow.java b/plugins/org.argeo.slc.client.ui/src/main/java/org/argeo/slc/client/ui/commands/RunSlcFlow.java
index 00f989d62..4ae7f97e6 100644
--- a/plugins/org.argeo.slc.client.ui/src/main/java/org/argeo/slc/client/ui/commands/RunSlcFlow.java
+++ b/plugins/org.argeo.slc.client.ui/src/main/java/org/argeo/slc/client/ui/commands/RunSlcFlow.java
@@ -1,3 +1,19 @@
+/*
+ * Copyright (C) 2007-2012 Mathieu Baudier
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *         http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
 package org.argeo.slc.client.ui.commands;
 
 import java.util.HashMap;
diff --git a/plugins/org.argeo.slc.client.ui/src/main/java/org/argeo/slc/client/ui/decorators/ResultFailedDecorator.java b/plugins/org.argeo.slc.client.ui/src/main/java/org/argeo/slc/client/ui/decorators/ResultFailedDecorator.java
new file mode 100644
index 000000000..1d021e2a3
--- /dev/null
+++ b/plugins/org.argeo.slc.client.ui/src/main/java/org/argeo/slc/client/ui/decorators/ResultFailedDecorator.java
@@ -0,0 +1,67 @@
+/*
+ * Copyright (C) 2007-2012 Mathieu Baudier
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *         http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+package org.argeo.slc.client.ui.decorators;
+
+import org.apache.commons.logging.Log;
+import org.apache.commons.logging.LogFactory;
+import org.argeo.slc.client.ui.ClientUiPlugin;
+import org.argeo.slc.client.ui.model.ResultParent;
+import org.eclipse.jface.resource.ImageDescriptor;
+import org.eclipse.jface.viewers.DecorationOverlayIcon;
+import org.eclipse.jface.viewers.IDecoration;
+import org.eclipse.jface.viewers.ILabelDecorator;
+import org.eclipse.jface.viewers.LabelProvider;
+import org.eclipse.swt.graphics.Image;
+import org.eclipse.ui.ISharedImages;
+
+public class ResultFailedDecorator extends LabelProvider implements
+		ILabelDecorator {
+
+	private final static Log log = LogFactory
+			.getLog(ResultFailedDecorator.class);
+
+	public ResultFailedDecorator() {
+		super();
+	}
+
+	// Method to decorate Image
+	public Image decorateImage(Image image, Object object) {
+
+		// This method returns an annotated image or null if the
+		// image need not be decorated. Returning a null image
+		// decorates resource icon with basic decorations provided
+		// by Eclipse
+		if (object instanceof ResultParent) {
+			log.debug("decorate : " + ((ResultParent) object).getName()
+					+ " - passed : " + ((ResultParent) object).isPassed());
+			if (!((ResultParent) object).isPassed()) {
+				ImageDescriptor desc = ClientUiPlugin.getDefault()
+						.getWorkbench().getSharedImages()
+						.getImageDescriptor(ISharedImages.IMG_DEC_FIELD_ERROR);
+				DecorationOverlayIcon decoratedImage = new DecorationOverlayIcon(
+						image, desc, IDecoration.TOP_LEFT);
+				return decoratedImage.createImage();
+			} else
+				return null;
+		}
+		return null;
+	}
+
+	// Method to decorate Text
+	public String decorateText(String label, Object object) {
+		return null;
+	}
+}
diff --git a/plugins/org.argeo.slc.client.ui/src/main/java/org/argeo/slc/client/ui/model/ResultFolder.java b/plugins/org.argeo.slc.client.ui/src/main/java/org/argeo/slc/client/ui/model/ResultFolder.java
new file mode 100644
index 000000000..ac4eb9f7c
--- /dev/null
+++ b/plugins/org.argeo.slc.client.ui/src/main/java/org/argeo/slc/client/ui/model/ResultFolder.java
@@ -0,0 +1,140 @@
+/*
+ * Copyright (C) 2007-2012 Mathieu Baudier
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *         http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+package org.argeo.slc.client.ui.model;
+
+import javax.jcr.Node;
+import javax.jcr.NodeIterator;
+import javax.jcr.RepositoryException;
+
+import org.argeo.slc.SlcException;
+import org.argeo.slc.jcr.SlcNames;
+import org.argeo.slc.jcr.SlcTypes;
+
+/**
+ * UI Tree component that wrap a node of type ResultFolder. list either other
+ * folders and/or a list of results. keeps a reference to its parent.
+ */
+public class ResultFolder extends ResultParent {
+
+	private Node node = null;
+
+	/**
+	 * 
+	 * @param parent
+	 * @param node
+	 *            throws an exception if null
+	 * @param name
+	 */
+	public ResultFolder(ResultFolder parent, Node node, String name) {
+		super(name);
+		try {
+			if (node == null)
+				throw new SlcException("Node Object cannot be null");
+			setParent(parent);
+			this.node = node;
+			// initialize passed status
+			setPassed(node.getNode(SlcNames.SLC_STATUS)
+					.getProperty(SlcNames.SLC_SUCCESS).getBoolean());
+		} catch (RepositoryException re) {
+			throw new SlcException(
+					"Unexpected error while initializing result folder : "
+							+ getName(), re);
+		}
+
+	}
+
+	@Override
+	protected void initialize() {
+		try {
+			NodeIterator ni = node.getNodes();
+			while (ni.hasNext()) {
+				Node currNode = ni.nextNode();
+				if (currNode.isNodeType(SlcTypes.SLC_TEST_RESULT)) {
+					SingleResultNode srn = new SingleResultNode(this, currNode,
+							currNode.getProperty(SlcNames.SLC_TEST_CASE)
+									.getString());
+					addChild(srn);
+				} else if (currNode.isNodeType(SlcTypes.SLC_RESULT_FOLDER)) {
+					// FIXME change label
+					ResultFolder rf = new ResultFolder(this, currNode,
+							currNode.getName());
+					addChild(rf);
+				}
+			}
+		} catch (RepositoryException re) {
+			throw new SlcException(
+					"Unexpected error while initializing result folder : "
+							+ getName(), re);
+		}
+	}
+
+	@Override
+	public synchronized void dispose() {
+		super.dispose();
+	}
+
+	public Node getNode() {
+		return node;
+	}
+
+	// /** Override normal behavior to initialize display */
+	// @Override
+	// public synchronized Object[] getChildren() {
+	// if (isLoaded()) {
+	// return super.getChildren();
+	// } else {
+	// // initialize current object
+	// try {
+	// if (node != null) {
+	// NodeIterator ni = node.getNodes();
+	// while (ni.hasNext()) {
+	// Node currNode = ni.nextNode();
+	// if (currNode.isNodeType(SlcTypes.SLC_TEST_RESULT))
+	// addChild(new SingleResultNode(this, node, node
+	// .getProperty(SlcNames.SLC_TEST_CASE)
+	// .getString()));
+	// else if (currNode
+	// .isNodeType(SlcTypes.SLC_RESULT_FOLDER))
+	// addChild(new ResultFolder(this, node,
+	// node.getName()));
+	// }
+	// }
+	// return super.getChildren();
+	// } catch (RepositoryException e) {
+	// throw new ArgeoException(
+	// "Cannot initialize WorkspaceNode UI object."
+	// + getName(), e);
+	// }
+	// }
+	// }
+
+	// @Override
+	// public boolean refreshPassedStatus() {
+	// Object[] children = getChildren();
+	// isPassed = true;
+	// checkChildrenStatus: for (int i = 0; i <= children.length; i++) {
+	// if (children[i] instanceof ResultFolder) {
+	//
+	// }
+	// if (!((ResultParent) children[i]).isPassed()) {
+	// isPassed = false;
+	// break checkChildrenStatus;
+	// }
+	// }
+	// return isPassed;
+	// }
+
+}
\ No newline at end of file
diff --git a/plugins/org.argeo.slc.client.ui/src/main/java/org/argeo/slc/client/ui/model/ResultParent.java b/plugins/org.argeo.slc.client.ui/src/main/java/org/argeo/slc/client/ui/model/ResultParent.java
new file mode 100644
index 000000000..ecbffcae4
--- /dev/null
+++ b/plugins/org.argeo.slc.client.ui/src/main/java/org/argeo/slc/client/ui/model/ResultParent.java
@@ -0,0 +1,54 @@
+/*
+ * Copyright (C) 2007-2012 Mathieu Baudier
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *         http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+package org.argeo.slc.client.ui.model;
+
+import org.argeo.eclipse.ui.TreeParent;
+
+/**
+ * Common base UI object to build result Tree.
+ */
+
+public abstract class ResultParent extends TreeParent {
+
+	public ResultParent(String name) {
+		super(name);
+	}
+
+	private boolean isPassed = true;
+
+	protected synchronized void setPassed(boolean isPassed) {
+		this.isPassed = isPassed;
+	}
+
+	public boolean isPassed() {
+		return isPassed;
+	}
+
+	@Override
+	public synchronized boolean hasChildren() {
+		if (!isLoaded())
+			initialize();
+		return super.hasChildren();
+	}
+
+	public void forceFullRefresh() {
+		clearChildren();
+		initialize();
+	}
+
+	protected abstract void initialize();
+
+}
diff --git a/plugins/org.argeo.slc.client.ui/src/main/java/org/argeo/slc/client/ui/model/SimpleNodeFolder.java b/plugins/org.argeo.slc.client.ui/src/main/java/org/argeo/slc/client/ui/model/SimpleNodeFolder.java
new file mode 100644
index 000000000..c08dafd80
--- /dev/null
+++ b/plugins/org.argeo.slc.client.ui/src/main/java/org/argeo/slc/client/ui/model/SimpleNodeFolder.java
@@ -0,0 +1,80 @@
+/*
+ * Copyright (C) 2007-2012 Mathieu Baudier
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *         http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+package org.argeo.slc.client.ui.model;
+
+import javax.jcr.Node;
+import javax.jcr.NodeIterator;
+import javax.jcr.RepositoryException;
+import javax.jcr.nodetype.NodeType;
+
+import org.argeo.slc.SlcException;
+import org.argeo.slc.jcr.SlcNames;
+import org.argeo.slc.jcr.SlcTypes;
+
+/**
+ * UI Tree component that wrap a node of type NT_UNSTRUCTURED. list either other
+ * folders and/or a list of results. keeps a reference to its parent.
+ */
+public class SimpleNodeFolder extends ResultParent {
+
+	private Node node = null;
+
+	/**
+	 * 
+	 * @param parent
+	 * @param node
+	 *            throws an exception if null
+	 * @param name
+	 */
+	public SimpleNodeFolder(SimpleNodeFolder parent, Node node, String name) {
+		super(name);
+		if (node == null)
+			throw new SlcException("Node Object cannot be null");
+		setParent(parent);
+		this.node = node;
+	}
+
+	@Override
+	protected void initialize() {
+		try {
+			NodeIterator ni = node.getNodes();
+			while (ni.hasNext()) {
+				Node currNode = ni.nextNode();
+				if (currNode.isNodeType(SlcTypes.SLC_TEST_RESULT)) {
+					SingleResultNode srn = new SingleResultNode(this, currNode,
+							currNode.getProperty(SlcNames.SLC_TEST_CASE)
+									.getString());
+					addChild(srn);
+				} else if (currNode.isNodeType(NodeType.NT_UNSTRUCTURED))
+					addChild(new SimpleNodeFolder(this, currNode,
+							currNode.getName()));
+			}
+		} catch (RepositoryException re) {
+			throw new SlcException(
+					"Unexpected error while initializing simple node folder : "
+							+ getName(), re);
+		}
+	}
+
+	@Override
+	public synchronized void dispose() {
+		super.dispose();
+	}
+
+	public Node getNode() {
+		return node;
+	}
+}
\ No newline at end of file
diff --git a/plugins/org.argeo.slc.client.ui/src/main/java/org/argeo/slc/client/ui/model/SingleResultNode.java b/plugins/org.argeo.slc.client.ui/src/main/java/org/argeo/slc/client/ui/model/SingleResultNode.java
new file mode 100644
index 000000000..5a08349a9
--- /dev/null
+++ b/plugins/org.argeo.slc.client.ui/src/main/java/org/argeo/slc/client/ui/model/SingleResultNode.java
@@ -0,0 +1,87 @@
+/*
+ * Copyright (C) 2007-2012 Mathieu Baudier
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *         http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+package org.argeo.slc.client.ui.model;
+
+import javax.jcr.Node;
+import javax.jcr.RepositoryException;
+import javax.jcr.Workspace;
+
+import org.argeo.eclipse.ui.TreeParent;
+import org.argeo.slc.SlcException;
+import org.argeo.slc.jcr.SlcNames;
+
+/**
+ * UI Tree component. Wraps a result node of a JCR {@link Workspace}. It also
+ * keeps a reference to its parent node that can either be a
+ * {@link ResultFolder}, a {@link SingleResultNode} or a {@link VirtualFolder}.
+ * It has no child.
+ */
+
+public class SingleResultNode extends ResultParent {
+
+	private final Node node;
+	private boolean passed;
+
+	// keeps a local reference to the node's name to avoid exception when the
+	// session is lost
+
+	/** Creates a new UiNode in the UI Tree */
+	public SingleResultNode(TreeParent parent, Node node, String name) {
+		super(name);
+		setParent(parent);
+		this.node = node;
+		setPassed(refreshPassedStatus());
+	}
+
+	public boolean refreshPassedStatus() {
+		try {
+			Node check = node.getNode(SlcNames.SLC_STATUS);
+			passed = check.getProperty(SlcNames.SLC_SUCCESS).getBoolean();
+			return passed;
+		} catch (RepositoryException re) {
+			throw new SlcException(
+					"Unexpected error while checking result status", re);
+		}
+	}
+
+	/** returns the node wrapped by the current UI object */
+	public Node getNode() {
+		return node;
+	}
+
+	/**
+	 * Override normal behavior : Results have no children for this view
+	 */
+	@Override
+	public synchronized Object[] getChildren() {
+		return null;
+	}
+
+	@Override
+	public boolean hasChildren() {
+		return false;
+	}
+
+	public boolean isPassed() {
+		return passed;
+	}
+
+	@Override
+	protected void initialize() {
+		// Do nothing this object is fully initialized at instantiation time.
+	}
+
+}
diff --git a/plugins/org.argeo.slc.client.ui/src/main/java/org/argeo/slc/client/ui/model/VirtualFolder.java b/plugins/org.argeo.slc.client.ui/src/main/java/org/argeo/slc/client/ui/model/VirtualFolder.java
new file mode 100644
index 000000000..c69e562d9
--- /dev/null
+++ b/plugins/org.argeo.slc.client.ui/src/main/java/org/argeo/slc/client/ui/model/VirtualFolder.java
@@ -0,0 +1,98 @@
+/*
+ * Copyright (C) 2007-2012 Mathieu Baudier
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *         http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+package org.argeo.slc.client.ui.model;
+
+import javax.jcr.Node;
+import javax.jcr.NodeIterator;
+import javax.jcr.RepositoryException;
+
+import org.argeo.ArgeoException;
+import org.argeo.slc.jcr.SlcNames;
+import org.argeo.slc.jcr.SlcTypes;
+
+/**
+ * UI Tree component. Virtual folder to list either other folders and/or a list
+ * of results. Keeps a reference to its parent that might be null if the .
+ */
+public class VirtualFolder extends ResultParent {
+
+	private Node node = null;
+	private boolean isPassed = true;
+
+	public VirtualFolder(VirtualFolder parent, Node node, String name) {
+		super(name);
+		setParent(parent);
+		this.node = node;
+	}
+
+	@Override
+	public synchronized void dispose() {
+		super.dispose();
+	}
+
+	/** Override normal behavior to initialize display */
+	@Override
+	public synchronized Object[] getChildren() {
+		if (isLoaded()) {
+			return super.getChildren();
+		} else {
+			// initialize current object
+			try {
+				if (node != null) {
+					NodeIterator ni = node.getNodes();
+					while (ni.hasNext()) {
+						Node currNode = ni.nextNode();
+						if (currNode.isNodeType(SlcTypes.SLC_TEST_RESULT))
+							addChild(new SingleResultNode(this, node, node
+									.getProperty(SlcNames.SLC_TEST_CASE)
+									.getString()));
+						else if (currNode
+								.isNodeType(SlcTypes.SLC_RESULT_FOLDER))
+							addChild(new VirtualFolder(this, node,
+									node.getName()));
+					}
+				}
+				return super.getChildren();
+			} catch (RepositoryException e) {
+				throw new ArgeoException(
+						"Cannot initialize WorkspaceNode UI object."
+								+ getName(), e);
+			}
+		}
+	}
+
+	// @Override
+	// public boolean refreshPassedStatus() {
+	// Object[] children = getChildren();
+	// isPassed = true;
+	// checkChildrenStatus: for (int i = 0; i <= children.length; i++) {
+	// if (children[i] instanceof VirtualFolder) {
+	//
+	// }
+	// if (!((ResultParent) children[i]).isPassed()) {
+	// isPassed = false;
+	// break checkChildrenStatus;
+	// }
+	// }
+	// return isPassed;
+	// }
+
+	@Override
+	protected void initialize() {
+		// TODO Auto-generated method stub
+	}
+
+}
\ No newline at end of file
diff --git a/plugins/org.argeo.slc.client.ui/src/main/java/org/argeo/slc/client/ui/providers/ResultTreeContentProvider.java b/plugins/org.argeo.slc.client.ui/src/main/java/org/argeo/slc/client/ui/providers/ResultTreeContentProvider.java
new file mode 100644
index 000000000..c2594ec13
--- /dev/null
+++ b/plugins/org.argeo.slc.client.ui/src/main/java/org/argeo/slc/client/ui/providers/ResultTreeContentProvider.java
@@ -0,0 +1,40 @@
+package org.argeo.slc.client.ui.providers;
+
+import org.argeo.eclipse.ui.TreeParent;
+import org.eclipse.jface.viewers.ITreeContentProvider;
+import org.eclipse.jface.viewers.Viewer;
+
+/** Basic content provider for a tree of result */
+public class ResultTreeContentProvider implements ITreeContentProvider {
+
+	/**
+	 * @param parent
+	 *            Pass current user home as parameter
+	 * 
+	 */
+	public Object[] getElements(Object parent) {
+		if (parent instanceof Object[])
+			return (Object[]) parent;
+		else
+			return null;
+	}
+
+	public Object getParent(Object child) {
+		return ((TreeParent) child).getParent();
+	}
+
+	public Object[] getChildren(Object parent) {
+		return ((TreeParent) parent).getChildren();
+	}
+
+	public boolean hasChildren(Object parent) {
+		return ((TreeParent) parent).hasChildren();
+	}
+
+	public void dispose() {
+		// FIXME implement if needed
+	}
+
+	public void inputChanged(Viewer viewer, Object oldInput, Object newInput) {
+	}
+}
\ No newline at end of file
diff --git a/plugins/org.argeo.slc.client.ui/src/main/java/org/argeo/slc/client/ui/providers/ResultTreeLabelProvider.java b/plugins/org.argeo.slc.client.ui/src/main/java/org/argeo/slc/client/ui/providers/ResultTreeLabelProvider.java
new file mode 100644
index 000000000..251f066ea
--- /dev/null
+++ b/plugins/org.argeo.slc.client.ui/src/main/java/org/argeo/slc/client/ui/providers/ResultTreeLabelProvider.java
@@ -0,0 +1,30 @@
+package org.argeo.slc.client.ui.providers;
+
+import org.argeo.eclipse.ui.TreeParent;
+import org.argeo.slc.client.ui.SlcImages;
+import org.argeo.slc.client.ui.model.ResultParent;
+import org.argeo.slc.client.ui.model.SingleResultNode;
+import org.eclipse.jface.viewers.LabelProvider;
+import org.eclipse.swt.graphics.Image;
+
+/** Basic label provider for a tree of result */
+public class ResultTreeLabelProvider extends LabelProvider {
+
+	@Override
+	public String getText(Object element) {
+		return ((TreeParent) element).getName();
+	}
+
+	public Image getImage(Object obj) {
+		if (obj instanceof SingleResultNode) {
+			// FIXME add realtime modification of process icon (SCHEDULED,
+			// RUNNING, COMPLETED...)
+			// Node resultNode = ((SingleResultNode) obj).getNode();
+			// int status = SlcJcrUtils.aggregateTestStatus(resultNode);
+			return SlcImages.PROCESS_COMPLETED;
+		} else if (obj instanceof ResultParent)
+			return SlcImages.FOLDER;
+		else
+			return null;
+	}
+}
diff --git a/plugins/org.argeo.slc.client.ui/src/main/java/org/argeo/slc/client/ui/views/JcrResultListView.java b/plugins/org.argeo.slc.client.ui/src/main/java/org/argeo/slc/client/ui/views/JcrResultListView.java
index 322256b71..e4e3575e6 100644
--- a/plugins/org.argeo.slc.client.ui/src/main/java/org/argeo/slc/client/ui/views/JcrResultListView.java
+++ b/plugins/org.argeo.slc.client.ui/src/main/java/org/argeo/slc/client/ui/views/JcrResultListView.java
@@ -35,7 +35,7 @@ import org.argeo.jcr.JcrUtils;
 import org.argeo.slc.SlcException;
 import org.argeo.slc.client.ui.editors.ProcessEditor;
 import org.argeo.slc.client.ui.editors.ProcessEditorInput;
-import org.argeo.slc.jcr.SlcJcrConstants;
+import org.argeo.slc.jcr.SlcJcrResultUtils;
 import org.argeo.slc.jcr.SlcNames;
 import org.argeo.slc.jcr.SlcTypes;
 import org.eclipse.jface.viewers.ColumnLabelProvider;
@@ -87,12 +87,12 @@ public class JcrResultListView extends ViewPart implements SlcNames {
 		try {
 			ObservationManager observationManager = session.getWorkspace()
 					.getObservationManager();
-			String[] nodeTypes = { SlcTypes.SLC_RESULT };
+			String[] nodeTypes = { SlcTypes.SLC_TEST_RESULT };
 			// FIXME Will not be notified if empty result is deleted
 			observationManager.addEventListener(resultsObserver,
 					Event.PROPERTY_ADDED | Event.NODE_REMOVED,
-					SlcJcrConstants.RESULTS_BASE_PATH, true, null, nodeTypes,
-					false);
+					SlcJcrResultUtils.getSlcResultsBasePath(session), true,
+					null, nodeTypes, false);
 		} catch (RepositoryException e) {
 			throw new SlcException("Cannot register listeners", e);
 		}
@@ -167,7 +167,8 @@ public class JcrResultListView extends ViewPart implements SlcNames {
 		public Object[] getElements(Object inputElement) {
 			try {
 				// TODO filter, optimize with virtual table, ...
-				String sql = "SELECT * from [slc:result] ORDER BY [jcr:lastModified] DESC";
+				String sql = "SELECT * from [" + SlcTypes.SLC_TEST_RESULT
+						+ "] ORDER BY [jcr:lastModified] DESC";
 				Query query = session.getWorkspace().getQueryManager()
 						.createQuery(sql, Query.JCR_SQL2);
 				// TODO paging
@@ -276,5 +277,4 @@ public class JcrResultListView extends ViewPart implements SlcNames {
 	public void setSession(Session session) {
 		this.session = session;
 	}
-
 }
\ No newline at end of file
diff --git a/plugins/org.argeo.slc.client.ui/src/main/java/org/argeo/slc/client/ui/views/JcrResultTreeView.java b/plugins/org.argeo.slc.client.ui/src/main/java/org/argeo/slc/client/ui/views/JcrResultTreeView.java
new file mode 100644
index 000000000..443674b2f
--- /dev/null
+++ b/plugins/org.argeo.slc.client.ui/src/main/java/org/argeo/slc/client/ui/views/JcrResultTreeView.java
@@ -0,0 +1,620 @@
+package org.argeo.slc.client.ui.views;
+
+import java.util.ArrayList;
+import java.util.List;
+
+import javax.jcr.Node;
+import javax.jcr.NodeIterator;
+import javax.jcr.Property;
+import javax.jcr.PropertyIterator;
+import javax.jcr.PropertyType;
+import javax.jcr.RepositoryException;
+import javax.jcr.Session;
+import javax.jcr.Value;
+import javax.jcr.observation.Event;
+import javax.jcr.observation.EventListener;
+import javax.jcr.observation.ObservationManager;
+
+import org.apache.commons.logging.Log;
+import org.apache.commons.logging.LogFactory;
+import org.argeo.ArgeoException;
+import org.argeo.eclipse.ui.jcr.AsyncUiEventListener;
+import org.argeo.eclipse.ui.utils.CommandUtils;
+import org.argeo.jcr.JcrUtils;
+import org.argeo.slc.SlcException;
+import org.argeo.slc.client.ui.ClientUiPlugin;
+import org.argeo.slc.client.ui.commands.AddResultFolder;
+import org.argeo.slc.client.ui.model.ResultFolder;
+import org.argeo.slc.client.ui.model.ResultParent;
+import org.argeo.slc.client.ui.model.SimpleNodeFolder;
+import org.argeo.slc.client.ui.model.SingleResultNode;
+import org.argeo.slc.client.ui.providers.ResultTreeContentProvider;
+import org.argeo.slc.client.ui.providers.ResultTreeLabelProvider;
+import org.argeo.slc.jcr.SlcJcrResultUtils;
+import org.argeo.slc.jcr.SlcNames;
+import org.argeo.slc.jcr.SlcTypes;
+import org.eclipse.jface.action.IMenuListener;
+import org.eclipse.jface.action.IMenuManager;
+import org.eclipse.jface.action.MenuManager;
+import org.eclipse.jface.viewers.ColumnLabelProvider;
+import org.eclipse.jface.viewers.DecoratingLabelProvider;
+import org.eclipse.jface.viewers.ILabelDecorator;
+import org.eclipse.jface.viewers.ISelectionChangedListener;
+import org.eclipse.jface.viewers.IStructuredContentProvider;
+import org.eclipse.jface.viewers.IStructuredSelection;
+import org.eclipse.jface.viewers.SelectionChangedEvent;
+import org.eclipse.jface.viewers.TableViewer;
+import org.eclipse.jface.viewers.TableViewerColumn;
+import org.eclipse.jface.viewers.TreeViewer;
+import org.eclipse.jface.viewers.Viewer;
+import org.eclipse.jface.viewers.ViewerDropAdapter;
+import org.eclipse.swt.SWT;
+import org.eclipse.swt.custom.SashForm;
+import org.eclipse.swt.dnd.DND;
+import org.eclipse.swt.dnd.DragSourceEvent;
+import org.eclipse.swt.dnd.DragSourceListener;
+import org.eclipse.swt.dnd.TextTransfer;
+import org.eclipse.swt.dnd.Transfer;
+import org.eclipse.swt.dnd.TransferData;
+import org.eclipse.swt.layout.FillLayout;
+import org.eclipse.swt.layout.GridData;
+import org.eclipse.swt.layout.GridLayout;
+import org.eclipse.swt.widgets.Composite;
+import org.eclipse.swt.widgets.Display;
+import org.eclipse.swt.widgets.Menu;
+import org.eclipse.ui.ISharedImages;
+import org.eclipse.ui.IWorkbenchWindow;
+import org.eclipse.ui.part.ViewPart;
+
+/** SLC generic JCR Result tree view. */
+public class JcrResultTreeView extends ViewPart {
+	public final static String ID = ClientUiPlugin.ID + ".jcrResultTreeView";
+
+	private final static Log log = LogFactory.getLog(JcrResultTreeView.class);
+
+	/* DEPENDENCY INJECTION */
+	private Session session;
+
+	// This page widgets
+	private TreeViewer resultTreeViewer;
+	private TableViewer propertiesViewer;
+
+	private EventListener resultsObserver = null;
+
+	private final static String[] observedNodeTypes = { SlcTypes.SLC_TEST_RESULT };
+
+	/**
+	 * To be overridden to adapt size of form and result frames.
+	 */
+	protected int[] getWeights() {
+		return new int[] { 70, 30 };
+	}
+
+	@Override
+	public void createPartControl(Composite parent) {
+		parent.setLayout(new FillLayout());
+		// Main layout
+		SashForm sashForm = new SashForm(parent, SWT.VERTICAL);
+		sashForm.setSashWidth(4);
+		sashForm.setLayout(new FillLayout());
+
+		// Create the tree on top of the view
+		Composite top = new Composite(sashForm, SWT.NONE);
+		GridLayout gl = new GridLayout(1, false);
+		top.setLayout(gl);
+		resultTreeViewer = createResultsTreeViewer(top);
+
+		// Create the property viewer on the bottom
+		Composite bottom = new Composite(sashForm, SWT.NONE);
+		bottom.setLayout(new GridLayout(1, false));
+		propertiesViewer = createPropertiesViewer(bottom);
+
+		sashForm.setWeights(getWeights());
+
+		// Refresh the view to initialize it
+		refresh(null);
+
+		try {
+			ObservationManager observationManager = session.getWorkspace()
+					.getObservationManager();
+			// FIXME Will not be notified if empty result is deleted
+			if (JcrUtils.getUserHome(session) != null) {
+				resultsObserver = new ResultObserver(resultTreeViewer.getTree()
+						.getDisplay());
+				observationManager.addEventListener(resultsObserver,
+						Event.PROPERTY_ADDED | Event.NODE_REMOVED, JcrUtils
+								.getUserHome(session).getPath(), true, null,
+						observedNodeTypes, false);
+			}
+		} catch (RepositoryException e) {
+			throw new SlcException("Cannot register listeners", e);
+		}
+
+	}
+
+	// The main tree viewer
+	protected TreeViewer createResultsTreeViewer(Composite parent) {
+		int style = SWT.BORDER | SWT.MULTI;
+
+		TreeViewer viewer = new TreeViewer(parent, style);
+		viewer.getTree().setLayoutData(
+				new GridData(SWT.FILL, SWT.FILL, true, true));
+
+		viewer.setContentProvider(new ResultTreeContentProvider());
+
+		// Add label provider with label decorator
+		ResultTreeLabelProvider rtLblProvider = new ResultTreeLabelProvider();
+		ILabelDecorator decorator = ClientUiPlugin.getDefault().getWorkbench()
+				.getDecoratorManager().getLabelDecorator();
+		viewer.setLabelProvider(new DecoratingLabelProvider(rtLblProvider,
+				decorator));
+		// viewer.setLabelProvider(rtLblProvider);
+		getSite().setSelectionProvider(viewer);
+
+		// add drag & drop support
+		int operations = DND.DROP_COPY | DND.DROP_MOVE;
+		Transfer[] tt = new Transfer[] { TextTransfer.getInstance() };
+		viewer.addDragSupport(operations, tt, new ViewDragListener());
+		viewer.addDropSupport(operations, tt, new ViewDropListener(viewer));
+
+		// add context menu
+		MenuManager menuManager = new MenuManager();
+		Menu menu = menuManager.createContextMenu(viewer.getTree());
+		menuManager.addMenuListener(new IMenuListener() {
+			public void menuAboutToShow(IMenuManager manager) {
+				contextMenuAboutToShow(manager);
+			}
+		});
+		viewer.getTree().setMenu(menu);
+		getSite().registerContextMenu(menuManager, viewer);
+
+		// add change listener to display TestResult information in the property
+		// viewer
+		viewer.addSelectionChangedListener(new ISelectionChangedListener() {
+			public void selectionChanged(SelectionChangedEvent event) {
+				if (!event.getSelection().isEmpty()) {
+					IStructuredSelection sel = (IStructuredSelection) event
+							.getSelection();
+					Object firstItem = sel.getFirstElement();
+					if (firstItem instanceof SingleResultNode)
+						propertiesViewer
+								.setInput(((SingleResultNode) firstItem)
+										.getNode());
+					else
+						propertiesViewer.setInput(null);
+				}
+			}
+		});
+
+		return viewer;
+	}
+
+	// Detailed property viewer
+	protected TableViewer createPropertiesViewer(Composite parent) {
+		propertiesViewer = new TableViewer(parent);
+		propertiesViewer.getTable().setLayoutData(
+				new GridData(SWT.FILL, SWT.FILL, true, true));
+		propertiesViewer.getTable().setHeaderVisible(true);
+		propertiesViewer.setContentProvider(new PropertiesContentProvider());
+		TableViewerColumn col = new TableViewerColumn(propertiesViewer,
+				SWT.NONE);
+		col.getColumn().setText("Name");
+		col.getColumn().setWidth(200);
+		col.setLabelProvider(new ColumnLabelProvider() {
+			public String getText(Object element) {
+				try {
+					return ((Property) element).getName();
+				} catch (RepositoryException e) {
+					throw new ArgeoException(
+							"Unexpected exception in label provider", e);
+				}
+			}
+		});
+		col = new TableViewerColumn(propertiesViewer, SWT.NONE);
+		col.getColumn().setText("Value");
+		col.getColumn().setWidth(400);
+		col.setLabelProvider(new ColumnLabelProvider() {
+			public String getText(Object element) {
+				try {
+					Property property = (Property) element;
+					if (property.getType() == PropertyType.BINARY)
+						return "<binary>";
+					else if (property.isMultiple()) {
+						StringBuffer buf = new StringBuffer("[");
+						Value[] values = property.getValues();
+						for (int i = 0; i < values.length; i++) {
+							if (i != 0)
+								buf.append(", ");
+							buf.append(values[i].getString());
+						}
+						buf.append(']');
+						return buf.toString();
+					} else
+						return property.getValue().getString();
+				} catch (RepositoryException e) {
+					throw new ArgeoException(
+							"Unexpected exception in label provider", e);
+				}
+			}
+		});
+		col = new TableViewerColumn(propertiesViewer, SWT.NONE);
+		col.getColumn().setText("Type");
+		col.getColumn().setWidth(200);
+		col.setLabelProvider(new ColumnLabelProvider() {
+			public String getText(Object element) {
+				try {
+					return PropertyType.nameFromValue(((Property) element)
+							.getType());
+				} catch (RepositoryException e) {
+					throw new ArgeoException(
+							"Unexpected exception in label provider", e);
+				}
+			}
+		});
+		propertiesViewer.setInput(getViewSite());
+		return propertiesViewer;
+	}
+
+	@Override
+	public void setFocus() {
+	}
+
+	/**
+	 * refreshes the passed node and its corresponding subtree.
+	 * 
+	 * @param node
+	 *            cannot be null
+	 * 
+	 */
+	public boolean jcrRefresh(Node node) {
+		boolean isPassed = true;
+		try {
+			if (node.isNodeType(SlcTypes.SLC_TEST_RESULT)) {
+				isPassed = node.getNode(SlcNames.SLC_STATUS)
+						.getProperty(SlcNames.SLC_SUCCESS).getBoolean();
+			} else if (node.isNodeType(SlcTypes.SLC_RESULT_FOLDER)) {
+				NodeIterator ni = node.getNodes();
+				// quicker but wrong : refresh will stop as soon as a failed
+				// test is found and the whole tree won't be refreshed
+				// while (isPassed && ni.hasNext()){
+				while (ni.hasNext()) {
+					Node currChild = ni.nextNode();
+					isPassed = isPassed & jcrRefresh(currChild);
+				}
+				if (isPassed != node.getNode(SlcNames.SLC_STATUS)
+						.getProperty(SlcNames.SLC_SUCCESS).getBoolean()) {
+					node.getNode(SlcNames.SLC_STATUS).setProperty(
+							SlcNames.SLC_SUCCESS, isPassed);
+					node.getSession().save();
+					return isPassed;
+				}
+			} else
+				; // do nothing
+		} catch (RepositoryException e) {
+			throw new SlcException("Cannot register listeners", e);
+		}
+		return isPassed;
+	}
+
+	/**
+	 * refreshes the passed resultParent and its corresponding subtree. It
+	 * refreshes the whole viewer if null is passed.
+	 * 
+	 * @param ResultParent
+	 * 
+	 */
+	public void refresh(ResultParent resultParent) {
+		if (resultParent == null) {
+			resultTreeViewer.setInput(initializeResultTree());
+			if (resultsObserver == null) {
+				// force initialization of the resultsObserver, only useful
+				// if the current view has been displayed before a single
+				// test has been run
+				try {
+					ObservationManager observationManager = session
+							.getWorkspace().getObservationManager();
+					resultsObserver = new ResultObserver(resultTreeViewer
+							.getTree().getDisplay());
+					observationManager.addEventListener(resultsObserver,
+							Event.PROPERTY_ADDED | Event.NODE_REMOVED, JcrUtils
+									.getUserHome(session).getPath(), true,
+							null, observedNodeTypes, false);
+				} catch (RepositoryException e) {
+					throw new SlcException("Cannot register listeners", e);
+				}
+			}
+
+		} else {
+			// FIXME implement refresh for a specific ResultParent object.
+			if (resultParent instanceof ResultFolder) {
+				ResultFolder currFolder = (ResultFolder) resultParent;
+				jcrRefresh(currFolder.getNode());
+				currFolder.forceFullRefresh();
+			}
+		}
+	}
+
+	private ResultParent[] initializeResultTree() {
+		ResultParent[] roots = new ResultParent[2];
+		try {
+			roots[0] = new ResultFolder(null,
+					SlcJcrResultUtils.getMyResultParentNode(session),
+					"My results");
+			Node otherResultsPar = session.getNode(SlcJcrResultUtils
+					.getSlcResultsBasePath(session));
+			roots[1] = new SimpleNodeFolder(null, otherResultsPar,
+					"All results");
+			return roots;
+		} catch (RepositoryException re) {
+			throw new ArgeoException(
+					"Unexpected error while initializing ResultTree.", re);
+		}
+	}
+
+	// Manage context menu
+	/**
+	 * Defines the commands that will pop up in the context menu.
+	 **/
+	protected void contextMenuAboutToShow(IMenuManager menuManager) {
+		IWorkbenchWindow window = ClientUiPlugin.getDefault().getWorkbench()
+				.getActiveWorkbenchWindow();
+
+		// Building conditions
+		IStructuredSelection selection = (IStructuredSelection) resultTreeViewer
+				.getSelection();
+		boolean isMyResultFolder = false;
+		if (selection.size() == 1) {
+			Object obj = selection.getFirstElement();
+			try {
+				Node targetParentNode = null;
+				if (obj instanceof ResultFolder) {
+					targetParentNode = ((ResultFolder) obj).getNode();
+
+					if (targetParentNode.isNodeType(SlcTypes.SLC_RESULT_FOLDER))
+						isMyResultFolder = true;
+				}
+			} catch (RepositoryException re) {
+				throw new SlcException(
+						"unexpected error while building condition for context menu",
+						re);
+			}
+		}
+		// Effective Refresh
+		CommandUtils.refreshCommand(menuManager, window, AddResultFolder.ID,
+				AddResultFolder.DEFAULT_LABEL,
+				ClientUiPlugin.getDefault().getWorkbench().getSharedImages()
+						.getImageDescriptor(ISharedImages.IMG_OBJ_ADD),
+				isMyResultFolder);
+	}
+
+	/* INNER CLASSES */
+	class ViewDragListener implements DragSourceListener {
+
+		public void dragStart(DragSourceEvent event) {
+			// Check if the drag action should start.
+
+			IStructuredSelection selection = (IStructuredSelection) resultTreeViewer
+					.getSelection();
+			boolean doIt = false;
+			// only one node at a time for the time being.
+			if (selection.size() == 1) {
+				Object obj = selection.getFirstElement();
+				if (obj instanceof SingleResultNode) {
+					Node tNode = ((SingleResultNode) obj).getNode();
+					try {
+						if (tNode.getPrimaryNodeType().isNodeType(
+								SlcTypes.SLC_TEST_RESULT)
+								&& (tNode.getPath()
+										.startsWith(SlcJcrResultUtils
+												.getSlcResultsBasePath(session))))
+							doIt = true;
+					} catch (RepositoryException re) {
+						throw new SlcException(
+								"unexpected error while validating drag source",
+								re);
+					}
+				}
+			}
+			event.doit = doIt;
+		}
+
+		public void dragSetData(DragSourceEvent event) {
+			IStructuredSelection selection = (IStructuredSelection) resultTreeViewer
+					.getSelection();
+			Object obj = selection.getFirstElement();
+			if (obj instanceof SingleResultNode) {
+				Node first = ((SingleResultNode) obj).getNode();
+				try {
+					event.data = first.getIdentifier();
+				} catch (RepositoryException re) {
+					throw new SlcException(
+							"unexpected error while setting data", re);
+				}
+			}
+		}
+
+		public void dragFinished(DragSourceEvent event) {
+			// implement here tree refresh in case of a move.
+		}
+	}
+
+	// Implementation of the Drop Listener
+	protected class ViewDropListener extends ViewerDropAdapter {
+
+		private Node currParentNode = null;
+
+		public ViewDropListener(Viewer viewer) {
+			super(viewer);
+		}
+
+		@Override
+		public boolean validateDrop(Object target, int operation,
+				TransferData transferType) {
+			boolean validDrop = false;
+			try {
+				// We can only drop under myResults
+				Node targetParentNode = null;
+				if (target instanceof ResultFolder) {
+					Node currNode = ((ResultFolder) target).getNode();
+
+					if (currNode.isNodeType(SlcTypes.SLC_RESULT_FOLDER)) {
+						targetParentNode = currNode;
+					}
+				} else if (target instanceof SingleResultNode) {
+					Node currNode = ((SingleResultNode) target).getNode();
+					if (currNode.getParent().isNodeType(
+							SlcTypes.SLC_RESULT_FOLDER))
+						targetParentNode = currNode.getParent();
+				}
+				if (targetParentNode != null) {
+					currParentNode = targetParentNode;
+					validDrop = true;
+				}
+			} catch (RepositoryException re) {
+				throw new SlcException(
+						"unexpected error while validating drop target", re);
+			}
+			return validDrop;
+		}
+
+		@Override
+		public boolean performDrop(Object data) {
+
+			try {
+				Node source = session.getNodeByIdentifier((String) data);
+				Node target = currParentNode.addNode(source.getName(), source
+						.getPrimaryNodeType().getName());
+				JcrUtils.copy(source, target);
+				updatePassedStatus(target, target.getNode(SlcNames.SLC_STATUS)
+						.getProperty(SlcNames.SLC_SUCCESS).getBoolean());
+				target.getSession().save();
+			} catch (RepositoryException re) {
+				throw new SlcException(
+						"unexpected error while copying dropped node", re);
+			}
+			return true;
+		}
+
+		/**
+		 * recursively update passed status of the parent ResultFolder and its
+		 * parent if needed
+		 * 
+		 * @param node
+		 *            cannot be null
+		 * 
+		 */
+		private void updatePassedStatus(Node node, boolean passed) {
+			try {
+				Node pNode = node.getParent();
+				boolean pStatus = pNode.getNode(SlcNames.SLC_STATUS)
+						.getProperty(SlcNames.SLC_SUCCESS).getBoolean();
+				if (pStatus == passed)
+					// nothing to update
+					return;
+				else if (!passed) {
+					// error we only update status of the result folder and its
+					// parent if needed
+					pNode.getNode(SlcNames.SLC_STATUS).setProperty(
+							SlcNames.SLC_SUCCESS, passed);
+					updatePassedStatus(pNode, passed);
+				} else {
+					// success we must first check if all siblings have also
+					// successfully completed
+					boolean success = true;
+					NodeIterator ni = pNode.getNodes();
+					children: while (ni.hasNext()) {
+						Node currNode = ni.nextNode();
+						if ((currNode.isNodeType(SlcTypes.SLC_DIFF_RESULT) || currNode
+								.isNodeType(SlcTypes.SLC_RESULT_FOLDER))
+								&& !currNode.getNode(SlcNames.SLC_STATUS)
+										.getProperty(SlcNames.SLC_SUCCESS)
+										.getBoolean()) {
+							success = false;
+							break children;
+						}
+					}
+					if (success) {
+						pNode.getNode(SlcNames.SLC_STATUS).setProperty(
+								SlcNames.SLC_SUCCESS, passed);
+						updatePassedStatus(pNode, passed);
+					} else
+						// one of the siblings had also the failed status so
+						// above tree remains unchanged.
+						return;
+				}
+
+			} catch (RepositoryException e) {
+				throw new SlcException("Cannot register listeners", e);
+			}
+		}
+	}
+
+	class ResultObserver extends AsyncUiEventListener {
+
+		public ResultObserver(Display display) {
+			super(display);
+		}
+
+		@Override
+		protected Boolean willProcessInUiThread(List<Event> events)
+				throws RepositoryException {
+			for (Event event : events) {
+				// getLog().debug("Received event " + event);
+				int eventType = event.getType();
+				if (eventType == Event.NODE_REMOVED)
+					return true;
+				String path = event.getPath();
+				int index = path.lastIndexOf('/');
+				String propertyName = path.substring(index + 1);
+				if (propertyName.equals(SlcNames.SLC_COMPLETED)
+						|| propertyName.equals(SlcNames.SLC_UUID)) {
+					return true;
+				}
+			}
+			return false;
+		}
+
+		protected void onEventInUiThread(List<Event> events)
+				throws RepositoryException {
+			// FIXME implement correct behaviour. treeViewer selection is
+			// disposed by the drag & drop.
+			// resultTreeViewer.refresh();
+			// refresh(null);
+			// log.warn("Implement refresh.");
+		}
+
+	}
+
+	class PropertiesContentProvider implements IStructuredContentProvider {
+		// private JcrItemsComparator itemComparator = new JcrItemsComparator();
+
+		public void dispose() {
+		}
+
+		public void inputChanged(Viewer viewer, Object oldInput, Object newInput) {
+		}
+
+		public Object[] getElements(Object inputElement) {
+			try {
+				if (inputElement instanceof Node) {
+					List<Property> props = new ArrayList<Property>();
+					PropertyIterator pit = ((Node) inputElement)
+							.getProperties();
+					while (pit.hasNext())
+						props.add(pit.nextProperty());
+					return props.toArray();
+				}
+				return new Object[] {};
+			} catch (RepositoryException e) {
+				throw new ArgeoException("Cannot get element for "
+						+ inputElement, e);
+			}
+		}
+	}
+
+	/* DEPENDENCY INJECTION */
+	public void setSession(Session session) {
+		this.session = session;
+	}
+
+}
diff --git a/runtime/org.argeo.slc.support.jcr/src/main/java/org/argeo/slc/jcr/JcrTestResult.java b/runtime/org.argeo.slc.support.jcr/src/main/java/org/argeo/slc/jcr/JcrTestResult.java
index f96e88ea7..818d4f333 100644
--- a/runtime/org.argeo.slc.support.jcr/src/main/java/org/argeo/slc/jcr/JcrTestResult.java
+++ b/runtime/org.argeo.slc.support.jcr/src/main/java/org/argeo/slc/jcr/JcrTestResult.java
@@ -38,13 +38,13 @@ import org.argeo.slc.test.TestResultPart;
 import org.argeo.slc.test.TestRun;
 import org.argeo.slc.test.TestStatus;
 
-/** {@link TestResult} wrapping a JCR node of type {@link SlcTypes#SLC_RESULT}. */
+/** {@link TestResult} wrapping a JCR node of type {@link SlcTypes#SLC_TEST_RESULT}. */
 public class JcrTestResult implements TestResult, SlcNames, AttachmentsEnabled {
 	/** Should only be set for an already existing result. */
 	private String uuid;
 	private Repository repository;
 	private Session session;
-	private String resultType = SlcTypes.SLC_RESULT;
+	private String resultType = SlcTypes.SLC_TEST_RESULT;
 
 	/** cached for performance purposes */
 	private String nodeIdentifier = null;
@@ -93,7 +93,8 @@ public class JcrTestResult implements TestResult, SlcNames, AttachmentsEnabled {
 			} else {
 				QueryManager qm = session.getWorkspace().getQueryManager();
 				Query q = qm.createQuery(
-						"select * from [slc:result] where [slc:uuid]='" + uuid
+						"select * from [" + SlcTypes.SLC_TEST_RESULT
+						+ "] where [slc:uuid]='" + uuid
 								+ "'", Query.JCR_SQL2);
 				resultNode = JcrUtils.querySingleNode(q);
 				if (resultNode != null)
@@ -111,9 +112,7 @@ public class JcrTestResult implements TestResult, SlcNames, AttachmentsEnabled {
 	public void addResultPart(TestResultPart testResultPart) {
 		Node node = getNode();
 		try {
-			// TODO: find a better way to name it by default
-			String partName = Long.toString(System.currentTimeMillis());
-			Node resultPartNode = node.addNode(partName, SlcTypes.SLC_CHECK);
+			Node resultPartNode = node.addNode(SlcNames.SLC_STATUS, SlcTypes.SLC_CHECK);
 			resultPartNode.setProperty(SLC_SUCCESS,
 					testResultPart.getStatus() == TestStatus.PASSED);
 			if (testResultPart.getMessage() != null)
diff --git a/runtime/org.argeo.slc.support.jcr/src/main/java/org/argeo/slc/jcr/SlcJcrConstants.java b/runtime/org.argeo.slc.support.jcr/src/main/java/org/argeo/slc/jcr/SlcJcrConstants.java
index a1e42f49b..6c36aa949 100644
--- a/runtime/org.argeo.slc.support.jcr/src/main/java/org/argeo/slc/jcr/SlcJcrConstants.java
+++ b/runtime/org.argeo.slc.support.jcr/src/main/java/org/argeo/slc/jcr/SlcJcrConstants.java
@@ -22,8 +22,13 @@ public interface SlcJcrConstants {
 	public final static String PROCESSES_BASE_PATH = SLC_BASE_PATH
 			+ "/slc:processes";
 	public final static String AGENTS_BASE_PATH = SLC_BASE_PATH + "/slc:agents";
-	public final static String RESULTS_BASE_PATH = SLC_BASE_PATH
-			+ "/slc:results";
+	// public final static String RESULTS_BASE_PATH = SLC_BASE_PATH
+	// + "/slc:results";
 	public final static String VM_AGENT_FACTORY_PATH = AGENTS_BASE_PATH
 			+ "/slc:vm";
+	
+	/*
+	 * SLC SPECIFIC JCR PATHS
+	 */
+	public final static String SLC_MYRESULT_BASEPATH = "slc:myResults/";
 }
diff --git a/runtime/org.argeo.slc.support.jcr/src/main/java/org/argeo/slc/jcr/SlcJcrResultUtils.java b/runtime/org.argeo.slc.support.jcr/src/main/java/org/argeo/slc/jcr/SlcJcrResultUtils.java
new file mode 100644
index 000000000..9546c3508
--- /dev/null
+++ b/runtime/org.argeo.slc.support.jcr/src/main/java/org/argeo/slc/jcr/SlcJcrResultUtils.java
@@ -0,0 +1,110 @@
+/*
+ * Copyright (C) 2007-2012 Mathieu Baudier
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *         http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+package org.argeo.slc.jcr;
+
+import javax.jcr.Node;
+import javax.jcr.RepositoryException;
+import javax.jcr.Session;
+
+import org.argeo.ArgeoException;
+import org.argeo.jcr.JcrUtils;
+import org.argeo.slc.SlcException;
+
+/**
+ * Utilities around the SLC JCR Result model. Note that it relies on fixed base
+ * paths (convention over configuration) for optimization purposes.
+ */
+public class SlcJcrResultUtils {
+
+	/**
+	 * Returns the path to the current slc:result node
+	 */
+	public static String getSlcResultsBasePath(Session session) {
+		try {
+
+			return JcrUtils.getUserHome(session).getPath() + "/"
+					+ SlcNames.SLC_RESULTS;
+		} catch (RepositoryException re) {
+			throw new ArgeoException(
+					"Unexpected error while getting Slc Results Base Path.", re);
+		}
+	}
+
+	/**
+	 * Returns the path to the current Result UI specific node, depending the
+	 * current user
+	 */
+	public static String getMyResultsBasePath(Session session) {
+		try {
+			return JcrUtils.getUserHome(session).getPath() + "/"
+					+ SlcJcrConstants.SLC_MYRESULT_BASEPATH;
+		} catch (RepositoryException re) {
+			throw new ArgeoException(
+					"Unexpected error while getting Slc Results Base Path.", re);
+		}
+	}
+
+	public static Node getMyResultParentNode(Session session) {
+		try {
+			if (session.nodeExists(SlcJcrResultUtils
+					.getMyResultsBasePath(session)))
+				return session.getNode(getMyResultsBasePath(session));
+			else
+				return createResultFolderNode(session,
+						getMyResultsBasePath(session));
+		} catch (RepositoryException re) {
+			throw new ArgeoException(
+					"Unexpected error while creating user MyResult base node.",
+					re);
+		}
+
+	}
+
+	/**
+	 * Creates a new node with type SlcTypes.SLC_RESULT_FOLDER at the given
+	 * absolute path. If a node already exists at the given path, returns that
+	 * node if it has the correct type and throws an exception otherwise.
+	 * 
+	 * @param session
+	 * @param absPath
+	 * @return
+	 */
+	public static synchronized Node createResultFolderNode(Session session,
+			String absPath) {
+		try {
+			if (session.nodeExists(absPath)) {
+				// Sanity check
+				Node currNode = session.getNode(absPath);
+				if (currNode.isNodeType(SlcTypes.SLC_RESULT_FOLDER))
+					return currNode;
+				else
+					throw new SlcException(
+							"A node already exists at this path : " + absPath
+									+ " that has the wrong type. ");
+			}
+			Node rfNode = JcrUtils.mkdirs(session, absPath);
+			rfNode.setPrimaryType(SlcTypes.SLC_RESULT_FOLDER);
+			Node statusNode = rfNode.addNode(SlcNames.SLC_STATUS,
+					SlcTypes.SLC_CHECK);
+			statusNode.setProperty(SlcNames.SLC_SUCCESS, true);
+			session.save();
+			return rfNode;
+		} catch (RepositoryException re) {
+			throw new ArgeoException(
+					"Unexpected error while creating Result Folder node.", re);
+		}
+	}
+}
\ No newline at end of file
diff --git a/runtime/org.argeo.slc.support.jcr/src/main/java/org/argeo/slc/jcr/SlcTypes.java b/runtime/org.argeo.slc.support.jcr/src/main/java/org/argeo/slc/jcr/SlcTypes.java
index 96b3d9e4d..25f830d97 100644
--- a/runtime/org.argeo.slc.support.jcr/src/main/java/org/argeo/slc/jcr/SlcTypes.java
+++ b/runtime/org.argeo.slc.support.jcr/src/main/java/org/argeo/slc/jcr/SlcTypes.java
@@ -31,10 +31,11 @@ public interface SlcTypes {
 	public final static String SLC_PRIMITIVE_SPEC_ATTRIBUTE = "slc:primitiveSpecAttribute";
 	public final static String SLC_REF_SPEC_ATTRIBUTE = "slc:refSpecAttribute";
 
-	public final static String SLC_RESULT = "slc:result";
+	public final static String SLC_TEST_RESULT = "slc:testResult";
 	public final static String SLC_CHECK = "slc:check";
 	public final static String SLC_PROPERTY = "slc:property";
 	public final static String SLC_DIFF_RESULT = "slc:diffResult";
+	public final static String SLC_RESULT_FOLDER = "slc:resultFolder";
 
 	// Log levels
 	public final static String SLC_LOG_ENTRY = "slc:logEntry";
@@ -60,7 +61,7 @@ public interface SlcTypes {
 	public final static String SLC_DYNAMIC_IMPORTED_PACKAGE = "slc:dynamicImportedPackage";
 	public final static String SLC_REQUIRED_BUNDLE = "slc:requiredBundle";
 	public final static String SLC_FRAGMENT_HOST = "slc:fragmentHost";
-	
+
 	// origin
 	public final static String SLC_KNOWN_ORIGIN = "slc:knownOrigin";
 	public final static String SLC_PROXIED = "slc:proxied";
diff --git a/runtime/org.argeo.slc.support.jcr/src/main/java/org/argeo/slc/jcr/execution/JcrResultListener.java b/runtime/org.argeo.slc.support.jcr/src/main/java/org/argeo/slc/jcr/execution/JcrResultListener.java
index 12ade515d..b5af2c8ec 100644
--- a/runtime/org.argeo.slc.support.jcr/src/main/java/org/argeo/slc/jcr/execution/JcrResultListener.java
+++ b/runtime/org.argeo.slc.support.jcr/src/main/java/org/argeo/slc/jcr/execution/JcrResultListener.java
@@ -169,7 +169,7 @@ public class JcrResultListener implements TreeTestResultListener, SlcNames {
 			throws RepositoryException {
 		String uuid = testResult.getUuid();
 		String path = SlcJcrUtils.createResultPath(session.getUserID(), uuid);
-		Node resultNode = JcrUtils.mkdirs(session, path, SlcTypes.SLC_RESULT);
+		Node resultNode = JcrUtils.mkdirs(session, path, SlcTypes.SLC_TEST_RESULT);
 		resultNode.setProperty(SLC_UUID, uuid);
 		for (Map.Entry<String, String> entry : testResult.getAttributes()
 				.entrySet()) {
diff --git a/runtime/org.argeo.slc.support.jcr/src/main/resources/org/argeo/slc/jcr/slc.cnd b/runtime/org.argeo.slc.support.jcr/src/main/resources/org/argeo/slc/jcr/slc.cnd
index 4e8a4e688..f527902cb 100644
--- a/runtime/org.argeo.slc.support.jcr/src/main/resources/org/argeo/slc/jcr/slc.cnd
+++ b/runtime/org.argeo.slc.support.jcr/src/main/resources/org/argeo/slc/jcr/slc.cnd
@@ -95,15 +95,21 @@ mixin
 + * (slc:executionSpecAttribute) *
 
 // RESULT
-[slc:result] > nt:unstructured, mix:created, mix:lastModified
+[slc:testResult] > nt:unstructured, mix:created, mix:lastModified
 - slc:uuid (STRING) ! m
 - slc:testCase (STRING)
 - slc:completed (DATE)
++ slc:testStatus (slc:check)
 
-[slc:diffResult] > slc:result
+[slc:diffResult] > slc:testResult
 + slc:summary
 + slc:issues
 
+[slc:resultFolder] > nt:unstructured
++ slc:folderStatus (slc:check)
++ * (slc:resultFolder) *
++ * (slc:testResult) *
+
 [slc:check] > nt:unstructured
 // true for PASSED, false for FAILED or ERROR
 - slc:success (BOOLEAN) ! m