for (Node node : nodes) {\r
Node parent = node.getParent();\r
node.remove();\r
- ResultParentUtils.updateStatusOnRemoval(parent);\r
+ ResultParentUtils.updatePassedStatus(parent,\r
+ true);\r
monitor.worked(1);\r
}\r
session.save();\r
}
}
- @Override
- public synchronized void dispose() {
- super.dispose();
- }
-
public Node getNode() {
return node;
}
- /**
- * Overriden in the specific case of "My result" root object to return an
- * ordered list of children
- */
- public synchronized Object[] getChildren() {
- Object[] children = super.getChildren();
- try {
- if (node.isNodeType(SlcTypes.SLC_MY_RESULT_ROOT_FOLDER))
- return ResultParentUtils.orderChildren(children);
- else
- return children;
- } catch (RepositoryException re) {
- throw new SlcException(
- "Unexpected error while initializing simple node folder : "
- + getName(), re);
- }
- }
+ // /**
+ // * Overriden in the specific case of "My result" root object to return an
+ // * ordered list of children
+ // */
+ // public synchronized Object[] getChildren() {
+ // Object[] children = super.getChildren();
+ // try {
+ // if (node.isNodeType(SlcTypes.SLC_MY_RESULT_ROOT_FOLDER))
+ // return ResultParentUtils.orderChildren(children);
+ // else
+ // return children;
+ // } catch (RepositoryException re) {
+ // throw new SlcException(
+ // "Unexpected error while initializing simple node folder : "
+ // + getName(), re);
+ // }
+ // }
}
\ No newline at end of file
* 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 ParentNodeFolder implements
- Comparable<ResultFolder> {
+public class ResultFolder extends ParentNodeFolder {
/**
*
}
}
- /**
- * Overriden to return an ordered list of children
- */
- public synchronized Object[] getChildren() {
- Object[] children = super.getChildren();
- return ResultParentUtils.orderChildren(children);
- }
-
- public int compareTo(ResultFolder o) {
- return super.compareTo(o);
- }
+ // /**
+ // * Overriden to return an ordered list of children
+ // */
+ // public synchronized Object[] getChildren() {
+ // Object[] children = super.getChildren();
+ // return ResultParentUtils.orderChildren(children);
+ // }
+ //
+ // public int compareTo(ResultFolder o) {
+ // return super.compareTo(o);
+ // }
}
\ No newline at end of file
--- /dev/null
+package org.argeo.slc.client.ui.model;
+
+import javax.jcr.Node;
+import javax.jcr.Property;
+import javax.jcr.RepositoryException;
+
+import org.argeo.eclipse.ui.TreeParent;
+import org.argeo.slc.SlcException;
+import org.argeo.slc.jcr.SlcNames;
+import org.argeo.slc.jcr.SlcTypes;
+import org.eclipse.jface.viewers.Viewer;
+import org.eclipse.jface.viewers.ViewerComparator;
+
+/** Enable specific sorting of the ResultTreeView */
+public class ResultItemsComparator extends ViewerComparator {
+
+ @Override
+ public int category(Object element) {
+ if (element instanceof SingleResultNode) {
+ return 10;
+
+ }
+ // folder always first
+ return 5;
+ }
+
+ @Override
+ public int compare(Viewer viewer, Object e1, Object e2) {
+ int cat1 = category(e1);
+ int cat2 = category(e2);
+
+ if (cat1 != cat2) {
+ return cat1 - cat2;
+ }
+
+ int result = 0;
+
+ if (e1 instanceof TreeParent && ((TreeParent) e1).getParent() == null) {
+ // preserve predefined order on UI root items
+ return 0;
+ }
+
+ if (e1 instanceof SingleResultNode && e2 instanceof SingleResultNode) {
+ Node an = ((SingleResultNode) e1).getNode();
+ Node bn = ((SingleResultNode) e2).getNode();
+ try {
+ // Order is different if we are under my Result or )in the
+ // rest of the tree structure
+ if (an.getParent().isNodeType(
+ SlcTypes.SLC_MY_RESULT_ROOT_FOLDER)
+ || an.getParent()
+ .isNodeType(SlcTypes.SLC_RESULT_FOLDER)) {
+ result = super.compare(viewer, e1, e2);
+ // Specific case of two result with same name
+ if (result == 0) {
+ result = an
+ .getProperty(SlcNames.SLC_COMPLETED)
+ .getDate()
+ .compareTo(
+ bn.getProperty(SlcNames.SLC_COMPLETED)
+ .getDate());
+ }
+ } else {
+ result = an
+ .getProperty(Property.JCR_CREATED)
+ .getDate()
+ .compareTo(
+ bn.getProperty(Property.JCR_CREATED)
+ .getDate());
+ result = result * -1; // last are displayed first
+ }
+ } catch (RepositoryException e) {
+ throw new SlcException("Unable to compare date created", e);
+ }
+ } else
+ // only remaining objects for the time being
+ // NT_UNSTRUCTURED that display all result tree structures
+ // We want the newest folders first
+ result = super.compare(viewer, e1, e2) * -1;
+ return result;
+ }
+}
--- /dev/null
+package org.argeo.slc.client.ui.model;
+
+import javax.jcr.RepositoryException;
+
+import org.argeo.slc.SlcException;
+import org.eclipse.jface.viewers.IElementComparer;
+
+/**
+ * Override default behaviour to insure that 2 distincts results that have the
+ * same name will be correctly and distincly returned by corresponding
+ * TreeViewer.getSelection() method.
+ *
+ */
+public class ResultItemsComparer implements IElementComparer {
+ // private final static Log log =
+ // LogFactory.getLog(ResultItemsComparer.class);
+
+ public boolean equals(Object a, Object b) {
+ if (b == null)
+ return a == null ? true : false;
+
+ if (a.hashCode() != b.hashCode() || !a.getClass().equals(b.getClass()))
+ return false;
+ else if (a instanceof SingleResultNode) {
+ try {
+ String ida = ((SingleResultNode) a).getNode().getIdentifier();
+
+ String idb = ((SingleResultNode) b).getNode().getIdentifier();
+
+ if (ida.equals(idb))
+ return true;
+ else
+ return false;
+
+ } catch (RepositoryException e) {
+ throw new SlcException("Cannot compare single reult nodes", e);
+ }
+ } else
+ return true;
+ }
+
+ public int hashCode(Object element) {
+ return element.hashCode();
+ }
+
+}
*/
package org.argeo.slc.client.ui.model;
+import java.util.Collections;
+
+import javax.jcr.Node;
+import javax.jcr.Property;
+import javax.jcr.RepositoryException;
+
import org.argeo.eclipse.ui.TreeParent;
+import org.argeo.slc.SlcException;
+import org.argeo.slc.jcr.SlcTypes;
/**
* Common base UI object to build result Tree.
initialize();
}
- public synchronized void dispose() {
- super.dispose();
- }
-
protected abstract void initialize();
}
package org.argeo.slc.client.ui.model;
import java.util.ArrayList;
-import java.util.Collections;
import java.util.Iterator;
import java.util.List;
// private final static Log log =
// LogFactory.getLog(ResultParentUtils.class);
- public static Object[] orderChildren(Object[] children) {
- List<ResultFolder> folders = new ArrayList<ResultFolder>();
- List<SingleResultNode> results = new ArrayList<SingleResultNode>();
- for (Object child : children) {
- if (child instanceof ResultFolder)
- folders.add((ResultFolder) child);
- else if (child instanceof SingleResultNode)
- results.add((SingleResultNode) child);
- }
-
- // Comparator first = Collections.reverseOrder();
- Collections.sort(folders);
- // Comparator<SingleResultNode> second = Collections.reverseOrder();
- Collections.sort(results);
-
- Object[] orderedChildren = new Object[folders.size() + results.size()];
- int i = 0;
- Iterator<ResultFolder> it = folders.iterator();
- while (it.hasNext()) {
- orderedChildren[i] = it.next();
- i++;
- }
- Iterator<SingleResultNode> it2 = results.iterator();
- while (it2.hasNext()) {
- orderedChildren[i] = it2.next();
- i++;
- }
- return orderedChildren;
- }
+ // public static Object[] orderChildren(Object[] children) {
+ // List<ResultFolder> folders = new ArrayList<ResultFolder>();
+ // List<SingleResultNode> results = new ArrayList<SingleResultNode>();
+ // for (Object child : children) {
+ // if (child instanceof ResultFolder)
+ // folders.add((ResultFolder) child);
+ // else if (child instanceof SingleResultNode)
+ // results.add((SingleResultNode) child);
+ // }
+ //
+ // // Comparator first = Collections.reverseOrder();
+ // Collections.sort(folders);
+ // // Comparator<SingleResultNode> second = Collections.reverseOrder();
+ // Collections.sort(results);
+ //
+ // Object[] orderedChildren = new Object[folders.size() + results.size()];
+ // int i = 0;
+ // Iterator<ResultFolder> it = folders.iterator();
+ // while (it.hasNext()) {
+ // orderedChildren[i] = it.next();
+ // i++;
+ // }
+ // Iterator<SingleResultNode> it2 = results.iterator();
+ // while (it2.hasNext()) {
+ // orderedChildren[i] = it2.next();
+ // i++;
+ // }
+ // return orderedChildren;
+ // }
public static List<Node> getResultsForDates(Session session,
List<String> dateRelPathes) {
}
/**
- * recursively update passed status of the parent ResultFolder and its
+ * recursively update passed status of the current ResultFolder and its
* parent if needed
*
* @param node
*/
public static void updatePassedStatus(Node node, boolean passed) {
try {
- Node pNode = node.getParent();
- if (!pNode.hasNode(SlcNames.SLC_STATUS))
+ if (!node.hasNode(SlcNames.SLC_STATUS))
// we have reached the root of the tree. stop the
// recursivity
return;
- boolean pStatus = pNode.getNode(SlcNames.SLC_STATUS)
+ boolean pStatus = node.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
+ // New status is 'failed' : we only update status of the result
+ // folder and its
// parent if needed
- pNode.getNode(SlcNames.SLC_STATUS).setProperty(
+ node.getNode(SlcNames.SLC_STATUS).setProperty(
SlcNames.SLC_SUCCESS, passed);
- updatePassedStatus(pNode, passed);
+ updatePassedStatus(node.getParent(), passed);
} else {
- // success we must first check if all siblings have also
+ // New status is 'passed': we must first check if all siblings
+ // have also
// successfully completed
boolean success = true;
- NodeIterator ni = pNode.getNodes();
+ NodeIterator ni = node.getNodes();
children: while (ni.hasNext()) {
Node currNode = ni.nextNode();
if ((currNode.isNodeType(SlcTypes.SLC_DIFF_RESULT) || currNode
}
}
if (success) {
- pNode.getNode(SlcNames.SLC_STATUS).setProperty(
+ node.getNode(SlcNames.SLC_STATUS).setProperty(
SlcNames.SLC_SUCCESS, passed);
- updatePassedStatus(pNode, passed);
+ updatePassedStatus(node.getParent(), 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);
+ throw new SlcException("Cannot update result passed status", e);
}
}
import org.argeo.slc.SlcException;
import org.argeo.slc.client.ui.SlcImages;
import org.argeo.slc.client.ui.SlcUiConstants;
+import org.argeo.slc.client.ui.model.ParentNodeFolder;
import org.argeo.slc.client.ui.model.ResultParent;
import org.argeo.slc.client.ui.model.SingleResultNode;
import org.eclipse.jface.viewers.LabelProvider;
@Override
public String getText(Object element) {
- if (element instanceof SingleResultNode) {
- Node node = ((SingleResultNode) element).getNode();
- try {
+ try {
+
+ if (element instanceof SingleResultNode) {
+ Node node = ((SingleResultNode) element).getNode();
if (node.isNodeType(NodeType.MIX_TITLE))
return node.getProperty(Property.JCR_TITLE).getString();
- } catch (RepositoryException e) {
- throw new SlcException("Unexpected error while getting "
- + "custom result label", e);
+
+ } else if (element instanceof ParentNodeFolder) {
+ Node node = ((ParentNodeFolder) element).getNode();
+ if (node.hasProperty(Property.JCR_TITLE))
+ return node.getProperty(Property.JCR_TITLE).getString();
}
+ } catch (RepositoryException e) {
+ throw new SlcException("Unexpected error while getting "
+ + "custom result label", e);
}
return ((TreeParent) element).getName();
}
import org.argeo.eclipse.ui.jcr.AsyncUiEventListener;\r
import org.argeo.eclipse.ui.utils.CommandUtils;\r
import org.argeo.jcr.JcrUtils;\r
-import org.argeo.jcr.UserJcrUtils;\r
import org.argeo.slc.SlcException;\r
import org.argeo.slc.client.ui.ClientUiPlugin;\r
import org.argeo.slc.client.ui.SlcUiConstants;\r
import org.argeo.slc.client.ui.editors.ProcessEditorInput;\r
import org.argeo.slc.client.ui.model.ParentNodeFolder;\r
import org.argeo.slc.client.ui.model.ResultFolder;\r
+import org.argeo.slc.client.ui.model.ResultItemsComparator;\r
+import org.argeo.slc.client.ui.model.ResultItemsComparer;\r
import org.argeo.slc.client.ui.model.ResultParent;\r
import org.argeo.slc.client.ui.model.ResultParentUtils;\r
import org.argeo.slc.client.ui.model.SingleResultNode;\r
private TreeViewer resultTreeViewer;\r
private TableViewer propertiesViewer;\r
\r
- private EventListener resultsObserver = null;\r
+ private EventListener myResultsObserver = null;\r
+ private EventListener allResultsObserver = null;\r
\r
- private final static String[] observedNodeTypes = {\r
+ // under My Results\r
+ private final static String[] observedNodeTypesUnderMyResult = {\r
SlcTypes.SLC_TEST_RESULT, SlcTypes.SLC_RESULT_FOLDER,\r
- NodeType.NT_UNSTRUCTURED };\r
+ SlcTypes.SLC_MY_RESULT_ROOT_FOLDER };\r
+\r
+ private final static String[] observedNodeTypesUnderAllResults = {\r
+ SlcTypes.SLC_TEST_RESULT, NodeType.NT_UNSTRUCTURED };\r
\r
// FIXME cache to ease D&D\r
private boolean isActionUnderMyResult = false;\r
- private ResultParent lastSelectedTargetElement;\r
+ // private ResultParent lastSelectedTargetElement;\r
private ResultParent lastSelectedSourceElement;\r
private ResultParent lastSelectedSourceElementParent;\r
private boolean isResultFolder = false;\r
\r
sashForm.setWeights(getWeights());\r
\r
- resultTreeViewer.setInput(initializeResultTree());\r
+ setOrderedInput(resultTreeViewer);\r
+\r
// Initialize observer\r
try {\r
ObservationManager observationManager = session.getWorkspace()\r
.getObservationManager();\r
- resultsObserver = new ResultObserver(resultTreeViewer.getTree()\r
- .getDisplay());\r
- observationManager.addEventListener(resultsObserver,\r
- Event.NODE_MOVED | Event.NODE_ADDED | Event.NODE_REMOVED,\r
- UserJcrUtils.getUserHome(session).getPath(), true, null,\r
- observedNodeTypes, false);\r
+ myResultsObserver = new MyResultsObserver(resultTreeViewer\r
+ .getTree().getDisplay());\r
+ allResultsObserver = new AllResultsObserver(resultTreeViewer\r
+ .getTree().getDisplay());\r
+\r
+ // observe tree changes under MyResults\r
+ observationManager.addEventListener(myResultsObserver,\r
+ Event.NODE_ADDED | Event.NODE_REMOVED,\r
+ SlcJcrResultUtils.getMyResultsBasePath(session), true,\r
+ null, observedNodeTypesUnderMyResult, false);\r
+ // observe tree changes under All results\r
+ observationManager.addEventListener(allResultsObserver,\r
+ Event.NODE_ADDED | Event.NODE_REMOVED,\r
+ SlcJcrResultUtils.getSlcResultsBasePath(session), true,\r
+ null, observedNodeTypesUnderAllResults, false);\r
} catch (RepositoryException e) {\r
throw new SlcException("Cannot register listeners", e);\r
}\r
}\r
\r
+ /**\r
+ * Override default behaviour so that default defined order remains\r
+ * unchanged on first level of the tree\r
+ */\r
+ private void setOrderedInput(TreeViewer viewer) {\r
+ // Add specific ordering\r
+ resultTreeViewer.setInput(null);\r
+ viewer.setComparator(null);\r
+ resultTreeViewer.setInput(initializeResultTree());\r
+ viewer.setComparator(new ResultItemsComparator());\r
+ }\r
+\r
// The main tree viewer\r
protected TreeViewer createResultsTreeViewer(Composite parent) {\r
int style = SWT.BORDER | SWT.MULTI;\r
decorator));\r
viewer.addDoubleClickListener(new ViewDoubleClickListener());\r
\r
+ // Override default behaviour to insure that 2 distincts results that\r
+ // have the same name will be correctly and distincly returned by\r
+ // corresponding\r
+ // TreeViewer.getSelection() method.\r
+ viewer.setComparer(new ResultItemsComparer());\r
+\r
// viewer.setLabelProvider(rtLblProvider);\r
getSite().setSelectionProvider(viewer);\r
\r
* \r
*/\r
public void refresh(ResultParent resultParent) {\r
- // if (log.isDebugEnabled())\r
- // log.debug("Refreshing '" + resultParent + "'...");\r
- // Thread.dumpStack();\r
if (resultParent == null) {\r
- resultTreeViewer.setInput(initializeResultTree());\r
+ if (!resultTreeViewer.getTree().isDisposed()) {\r
+ TreePath[] tps = resultTreeViewer.getExpandedTreePaths();\r
+ setOrderedInput(resultTreeViewer);\r
+ resultTreeViewer.setExpandedTreePaths(tps);\r
+ } else\r
+ setOrderedInput(resultTreeViewer);\r
} else {\r
if (resultParent instanceof ParentNodeFolder) {\r
ParentNodeFolder currFolder = (ParentNodeFolder) resultParent;\r
currFolder.forceFullRefresh();\r
}\r
// FIXME: specific refresh does not work\r
- // resultTreeViewer.refresh(currFolder, true);\r
- TreePath[] tps = resultTreeViewer.getExpandedTreePaths();\r
- resultTreeViewer.setInput(initializeResultTree());\r
- resultTreeViewer.setExpandedTreePaths(tps);\r
+ // resultTreeViewer.refresh(resultParent, true);\r
+ refresh(null);\r
}\r
}\r
\r
.getProperty(SlcNames.SLC_SUCCESS).getBoolean();\r
} else if (node.isNodeType(SlcTypes.SLC_RESULT_FOLDER)) {\r
NodeIterator ni = node.getNodes();\r
- // quicker but wrong : refresh will stop as soon as a failed\r
- // test is found and the whole tree won't be refreshed\r
- // while (isPassed && ni.hasNext()){\r
while (ni.hasNext()) {\r
Node currChild = ni.nextNode();\r
isPassed = isPassed & jcrRefresh(currChild);\r
if (doit) {\r
targetParentNode = tpNode;\r
validDrop = true;\r
- lastSelectedTargetElement = (ResultParent) target;\r
+ // lastSelectedTargetElement = (ResultParent) target;\r
}\r
}\r
} catch (RepositoryException re) {\r
try {\r
Node source = session.getNodeByIdentifier((String) data);\r
\r
- // Check is a node with same name already exists at destination\r
String name;\r
if (source.hasProperty(Property.JCR_TITLE))\r
name = source.getProperty(Property.JCR_TITLE).getString();\r
else\r
name = source.getName();\r
\r
- if (targetParentNode.hasNode(name)) {\r
+ // Check if a user defined folder result with same name exists\r
+ // at target\r
+ if (targetParentNode.hasNode(name)\r
+ && targetParentNode.getNode(name).isNodeType(\r
+ SlcTypes.SLC_RESULT_FOLDER)) {\r
ConfirmOverwriteWizard wizard = new ConfirmOverwriteWizard(\r
name, targetParentNode);\r
WizardDialog dialog = new WizardDialog(Display.getDefault()\r
}\r
\r
Node target;\r
+ boolean passedStatus = source.getNode(SlcNames.SLC_STATUS)\r
+ .getProperty(SlcNames.SLC_SUCCESS).getBoolean();\r
if (!isActionUnderMyResult) {// Copy\r
- target = targetParentNode.addNode(name, source\r
+ target = targetParentNode.addNode(source.getName(), source\r
.getPrimaryNodeType().getName());\r
JcrUtils.copy(source, target);\r
} else {// move\r
String destPath = targetParentNode.getPath() + "/" + name;\r
session.move(sourcePath, destPath);\r
// session.save();\r
+ // Update passed status of the parent source Node\r
+ ResultParentUtils.updatePassedStatus(\r
+ session.getNode(JcrUtils.parentPath(sourcePath)),\r
+ true);\r
target = session.getNode(destPath);\r
+\r
}\r
if (!target.isNodeType(NodeType.MIX_TITLE))\r
target.addMixin(NodeType.MIX_TITLE);\r
target.setProperty(Property.JCR_TITLE, name);\r
- ResultParentUtils\r
- .updatePassedStatus(target,\r
- target.getNode(SlcNames.SLC_STATUS)\r
- .getProperty(SlcNames.SLC_SUCCESS)\r
- .getBoolean());\r
+ ResultParentUtils.updatePassedStatus(target.getParent(),\r
+ passedStatus);\r
session.save();\r
} catch (RepositoryException re) {\r
throw new SlcException(\r
}\r
}\r
\r
- class ResultObserver extends AsyncUiEventListener {\r
+ class MyResultsObserver extends AsyncUiEventListener {\r
\r
- public ResultObserver(Display display) {\r
+ public MyResultsObserver(Display display) {\r
super(display);\r
}\r
\r
\r
protected void onEventInUiThread(List<Event> events)\r
throws RepositoryException {\r
- refresh(lastSelectedSourceElementParent);\r
+ List<Node> nodesToRefresh = new ArrayList<Node>();\r
+\r
+ for (Event event : events) {\r
+ String parPath = JcrUtils.parentPath(event.getPath());\r
+ if (session.nodeExists(parPath)) {\r
+ Node node = session.getNode(parPath);\r
+ if (!nodesToRefresh.contains(node)) {\r
+ nodesToRefresh.add(node);\r
+ }\r
+ }\r
+ }\r
+\r
+ // Update check nodes\r
+ for (Node node : nodesToRefresh)\r
+ jcrRefresh(node);\r
+ refresh(null);\r
\r
// boolean wasRemoved = false;\r
// boolean wasAdded = false;\r
}\r
}\r
\r
+ class AllResultsObserver extends AsyncUiEventListener {\r
+\r
+ public AllResultsObserver(Display display) {\r
+ super(display);\r
+ }\r
+\r
+ @Override\r
+ protected Boolean willProcessInUiThread(List<Event> events)\r
+ throws RepositoryException {\r
+ // unfiltered for the time being\r
+ return true;\r
+ }\r
+\r
+ protected void onEventInUiThread(List<Event> events)\r
+ throws RepositoryException {\r
+ for (Event event : events) {\r
+ if (log.isDebugEnabled())\r
+ log.debug("Received event " + event);\r
+ }\r
+ refresh(lastSelectedSourceElementParent);\r
+ }\r
+ }\r
+\r
class PropertiesContentProvider implements IStructuredContentProvider {\r
\r
public void dispose() {\r
else\r
propertiesViewer.setInput(null);\r
// update cache for Drag & drop\r
- lastSelectedTargetElement = firstItem;\r
+ // lastSelectedTargetElement = firstItem;\r
lastSelectedSourceElement = firstItem;\r
lastSelectedSourceElementParent = (ResultParent) firstItem\r
.getParent();\r
projects / gpl / argeo-slc.git / commitdiff