import org.aspectj.lang.ProceedingJoinPoint;
import org.aspectj.lang.annotation.Around;
import org.aspectj.lang.annotation.Aspect;
+import org.aspectj.lang.annotation.Pointcut;
import org.hibernate.LockMode;
import org.hibernate.SessionFactory;
private SessionFactory sessionFactory;
+ // We select here only getters from classes of the contentprovider package
+ // that need to get data from hibernate
+
+ // PointCuts
+ @Pointcut("(execution (* org.argeo.slc.client.contentprovider.ProcessListTableLabelProvider.get*(..)) && args(o,..))"
+ + " || (execution (* org.argeo.slc.client.contentprovider.ProcessDetailContentProvider.get*(..)) && args(o,..))")
+ void contentProviderGetterWrapper(Object o) {
+ }
+
// Advices
- @Around("execution (* org.argeo.slc.client.contentprovider.*.get*(Object, int))")
- public Object aroundGetVariable(ProceedingJoinPoint thisJoinPoint)
+ @Around("contentProviderGetterWrapper(o)")
+ public Object aroundGetWrapper(ProceedingJoinPoint thisJoinPoint, Object o)
throws Throwable {
- Object o = thisJoinPoint.getArgs()[0];
-
// TODO : find a mean to handle session & manager with txManager
// in order to not have to re-begin a transaction here.
sessionFactory.getCurrentSession().beginTransaction();
-
+
// reassociate a transient instance with a session (LockMode.NONE).
sessionFactory.getCurrentSession().lock(o, LockMode.NONE);
-
+
Object result = thisJoinPoint.proceed();
sessionFactory.getCurrentSession().getTransaction().commit();
return result;
--- /dev/null
+package org.argeo.slc.client.contentprovider;
+
+import java.util.List;
+
+import org.apache.commons.logging.Log;
+import org.apache.commons.logging.LogFactory;
+import org.argeo.slc.process.RealizedFlow;
+import org.argeo.slc.process.SlcExecution;
+import org.argeo.slc.process.SlcExecutionStep;
+import org.eclipse.jface.viewers.ITreeContentProvider;
+import org.eclipse.jface.viewers.Viewer;
+
+/**
+ * Basic tree view of the chosen process details
+ */
+public class ProcessDetailContentProvider implements ITreeContentProvider {
+ private final static Log log = LogFactory
+ .getLog(ProcessDetailContentProvider.class);
+
+ private SlcExecution slcExecution;
+
+ // private List<SlcAgent> slcAgents;
+
+ public Object[] getChildren(Object parent) {
+ if (parent instanceof SlcExecution) {
+ slcExecution = (SlcExecution) parent;
+
+ List<SlcExecutionStep> steps = slcExecution.getSteps();
+ List<RealizedFlow> realizedFlows = slcExecution.getRealizedFlows();
+
+ for (int i = 0; i < steps.size(); i++) {
+ log.debug("step[" + i + "] : " + steps.get(i).getType());
+ }
+ for (int i = 0; i < realizedFlows.size(); i++) {
+ log.debug("step[" + i + "] : "
+ + realizedFlows.get(i).toString());
+ }
+
+ log.debug(" Realized flows : ");
+ return steps.toArray();
+ }
+ // if (parent instanceof ExecutionModuleNode) {
+ // ExecutionModuleNode executionModuleNode = (ExecutionModuleNode)
+ // parent;
+ // ExecutionModuleDescriptor emd =
+ // executionModuleNode.getDescriptor();
+ // emd = executionModuleNode.getAgentNode().getAgent()
+ // .getExecutionModuleDescriptor(emd.getName(),
+ // emd.getVersion());
+ // executionModuleNode.cacheDescriptor(emd);
+ // // for (String flowName :
+ // executionModuleNode.getFlowDescriptors()
+ // // .keySet()) {
+ // // executionModuleNode.addChild(new FlowNode(flowName,
+ // // executionModuleNode));
+ // // }
+ // return executionModuleNode.getChildren();
+ // } else if (parent instanceof AgentNode) {
+ // AgentNode agentNode = (AgentNode) parent;
+ //
+ // if (log.isTraceEnabled())
+ // log.trace("Scan agent " + agentNode);
+ //
+ // agentNode.clearChildren();
+ // for (ExecutionModuleDescriptor desc : agentNode.getAgent()
+ // .listExecutionModuleDescriptors()) {
+ // agentNode.addChild(new ExecutionModuleNode(agentNode, desc));
+ // }
+ //
+ // return agentNode.getChildren();
+ // } else if (parent instanceof TreeParent) {
+ // return ((TreeParent) parent).getChildren();
+ // } else if (parent instanceof FlowNode) {
+ // return new Object[0];
+ // } else {
+ // List<AgentNode> agentNodes = new ArrayList<AgentNode>();
+ // for (SlcAgent slcAgent : slcAgents) {
+ // agentNodes.add(new AgentNode(slcAgent));
+ // }
+ // return agentNodes.toArray();
+ // }
+ return null;
+ }
+
+ public Object getParent(Object node) {
+ // if (node instanceof TreeObject) {
+ // return ((TreeObject) node).getParent();
+ // }
+ return null;
+ }
+
+ public boolean hasChildren(Object parent) {
+ // if (parent instanceof TreeParent && ((TreeParent) parent).isLoaded())
+ // {
+ // return ((TreeParent) parent).hasChildren();
+ // } else if (parent instanceof AgentNode) {
+ // return true;
+ // } else if (parent instanceof ExecutionModuleNode) {
+ // return true;
+ // }
+ return false;
+ }
+
+ public void inputChanged(Viewer v, Object oldInput, Object newInput) {
+ }
+
+ public void dispose() {
+ }
+
+ public Object[] getElements(Object parent) {
+ if (parent instanceof SlcExecution) {
+ slcExecution = (SlcExecution) parent;
+
+ List<SlcExecutionStep> steps = slcExecution.getSteps();
+ List<RealizedFlow> realizedFlows = slcExecution.getRealizedFlows();
+
+ for (int i = 0; i < steps.size(); i++) {
+ log.debug("step[" + i + "] : " + steps.get(i).getType());
+ }
+ for (int i = 0; i < realizedFlows.size(); i++) {
+ log.debug("step[" + i + "] : "
+ + realizedFlows.get(i).toString());
+ }
+
+ log.debug(" Realized flows : ");
+ return steps.toArray();
+ }
+ // return getChildren(parent);
+ return null;
+ }
+
+ // public class AgentNode extends TreeParent {
+ // private final SlcAgent agent;
+ //
+ // public AgentNode(SlcAgent agent) {
+ // super(agent.toString());
+ // this.agent = agent;
+ // }
+
+ // public SlcAgent getAgent() {
+ // return agent;
+ // }
+ // }
+
+ // public class ExecutionModuleNode extends TreeParent {
+ // private final AgentNode agentNode;
+ // private ExecutionModuleDescriptor descriptor;
+ // private Map<String, ExecutionFlowDescriptor> flowDescriptors;
+ //
+ // public ExecutionModuleNode(AgentNode agentNode,
+ // ExecutionModuleDescriptor descriptor) {
+ // super(descriptor.toString());
+ // this.agentNode = agentNode;
+ // this.descriptor = descriptor;
+ //
+ // }
+ //
+ // public AgentNode getAgentNode() {
+ // return agentNode;
+ // }
+ //
+ // public ExecutionModuleDescriptor getDescriptor() {
+ // return descriptor;
+ // }
+ // Object o = thisJoinPoint.getArgs()[0];
+
+ // public void cacheDescriptor(ExecutionModuleDescriptor descriptor) {
+ // this.descriptor = descriptor;
+ //
+ // SortedMap<String, FolderNode> folderNodes = new TreeMap<String,
+ // FolderNode>();
+ //
+ // flowDescriptors = new HashMap<String, ExecutionFlowDescriptor>();
+ // for (ExecutionFlowDescriptor fd : descriptor.getExecutionFlows()) {
+ // // if (log.isTraceEnabled())
+ // // log.trace("fd.path=" + fd.getPath() + ", fd.name="
+ // // + fd.getName());
+ //
+ // // find path and label
+ // String path;
+ // String label;
+ // int lastSlash = fd.getName().lastIndexOf('/');
+ // if ((fd.getPath() == null || fd.getPath().trim().equals(""))
+ // && lastSlash >= 0) {
+ // path = fd.getName().substring(0, lastSlash);
+ // label = fd.getName().substring(lastSlash + 1);
+ // } else {
+ // path = fd.getPath();
+ // label = fd.getName();
+ // }
+ // // if (log.isTraceEnabled())
+ // // log.trace("path=" + path + ", label=" + label);
+ //
+ // if (path == null || path.trim().equals("")
+ // || path.trim().equals("/")) {
+ // // directChildren.put(name, new FlowNode(name, this));
+ // addChild(new FlowNode(label, fd.getName(), this));
+ // } else {
+ // FolderNode folderNode = mkdirs(this, path, folderNodes);
+ // folderNode
+ // .addChild(new FlowNode(label, fd.getName(), this));
+ // }
+ //
+ // flowDescriptors.put(fd.getName(), fd);
+ // }
+ // // TODO: make it readonly
+ // }
+ //
+ // protected FolderNode mkdirs(TreeParent root, String path,
+ // SortedMap<String, FolderNode> folderNodes) {
+ // // Normalize
+ // if (path.charAt(0) != '/')
+ // path = '/' + path;
+ // if (path.charAt(path.length() - 1) == '/')
+ // path = path.substring(0, path.length() - 1);
+ //
+ // if (folderNodes.containsKey(path))
+ // return folderNodes.get(path);
+ //
+ // int lastIndx = path.lastIndexOf('/');
+ // String folderName;
+ // String parentPath;
+ // if (lastIndx >= 0) {
+ // folderName = path.substring(lastIndx + 1);
+ // parentPath = path.substring(0, lastIndx);
+ // } else {
+ // folderName = path;
+ // parentPath = "";
+ // }
+ //
+ // TreeParent parent;
+ // if (parentPath.equals(""))
+ // parent = root;
+ // else
+ // parent = mkdirs(root, parentPath, folderNodes);
+ // FolderNode newFolder = new FolderNode(folderName);
+ // parent.addChild(newFolder);
+ // folderNodes.put(path, newFolder);
+ // return newFolder;
+ // }
+ //
+ // public Map<String, ExecutionFlowDescriptor> getFlowDescriptors() {
+ // return flowDescriptors;
+ // }
+ //
+ // }
+ //
+ // public class FlowNode extends TreeObject {
+ // private final String flowName;
+ // private final ExecutionModuleNode executionModuleNode;
+ //
+ // public FlowNode(String label, String flowName,
+ // ExecutionModuleNode executionModuleNode) {
+ // super(label);
+ // this.flowName = flowName;
+ // this.executionModuleNode = executionModuleNode;
+ // }
+ //
+ // public String getFlowName() {
+ // return flowName;
+ // }
+ //
+ // public ExecutionModuleNode getExecutionModuleNode() {
+ // return executionModuleNode;
+ // }
+ //
+ // }
+ //
+ // public class FolderNode extends TreeParent {
+ // public FolderNode(String name) {
+ // super(name);
+ // }
+ //
+ // }
+}
http://www.springframework.org/schema/aop http://www.springframework.org/schema/aop/spring-aop-2.5.xsd
">
+ <!-- Providers -->
<bean id="processListTableLabelProvider"
class="org.argeo.slc.client.contentprovider.ProcessListTableLabelProvider" />
<bean id="processListStructuredContentProvider"
class="org.argeo.slc.client.contentprovider.ProcessListStructuredContentProvider" />
+ <bean id="processDetailContentProvider"
+ class="org.argeo.slc.client.contentprovider.ProcessDetailContentProvider"
+ scope="prototype" />
<!-- Aspects -->
<aop:aspectj-autoproxy />
<service ref="processListTableLabelProvider" interface="org.eclipse.jface.viewers.ITableLabelProvider" />\r
<service ref="processListStructuredContentProvider"\r
interface="org.eclipse.jface.viewers.IStructuredContentProvider" />\r
-\r
+ <service ref="processDetailContentProvider" interface="org.eclipse.jface.viewers.ITreeContentProvider" />\r
\r
<!-- References Needed -->\r
<reference id="slcExecutionDao" interface="org.argeo.slc.dao.process.SlcExecutionDao"\r
name="windowImages"
value="icons/argeo-icon-256.png">
</property>
+ <property
+ name="appName"
+ value="SLC">
+ </property>
</product>
</extension>
<!-- <extension
public void createInitialLayout(IPageLayout layout) {
String editorArea = layout.getEditorArea();
layout.setEditorAreaVisible(false);
- layout.setFixed(true);
+ layout.setFixed(false);
IFolderLayout topLeft = layout.createFolder("topLeft",
IPageLayout.LEFT, 0.5f, editorArea);
IFolderLayout bottomRight = layout.createFolder("bottomRight",
IPageLayout.BOTTOM, 0.6f, "topRight");
bottomRight.addView("org.argeo.slc.client.ui.processListView");
+ // bottomRight.addView("org.argeo.slc.client.ui.processDetailView");
+ bottomRight
+ .addPlaceholder("org.argeo.slc.client.ui.processDetailView:UUID-*");
+
+ // bottomRight.addView("org.argeo.slc.client.ui.resultListView");
IFolderLayout bottomLeft = layout.createFolder("bottomLeft",
IPageLayout.BOTTOM, 0.6f, "topLeft");
xsi:schemaLocation="http://www.springframework.org/schema/beans
http://www.springframework.org/schema/beans/spring-beans.xsd">
- <bean id="org.argeo.slc.client.ui.RefreshResultList"
+ <bean id="org.argeo.slc.client.ui.refreshResultList"
class="org.argeo.slc.client.ui.commands.ResultListViewRefreshHandler"
scope="prototype">
</bean>
- <bean id="org.argeo.slc.client.ui.RefreshProcessList"
+ <bean id="org.argeo.slc.client.ui.refreshProcessList"
class="org.argeo.slc.client.ui.commands.ProcessListViewRefreshHandler"
scope="prototype">
</bean>
+ <bean id="org.argeo.slc.client.ui.displayProcessDetails"
+ class="org.argeo.slc.client.ui.commands.ProcessDetailsDisplayHandler"
+ scope="prototype">
+ </bean>
</beans>
context-class-loader="service-provider" />\r
\r
<!-- Content providers are deported in an other bundle for UI not to depend \r
- on DB used implementation -->\r
+ on DB used implementation. We use bean-name reference because interface is \r
+ not enough to choose between various been with same interface -->\r
<reference id="processListTableLabelProvider" interface="org.eclipse.jface.viewers.ITableLabelProvider"\r
bean-name="processListTableLabelProvider" />\r
<reference id="processListStructuredContentProvider"\r
interface="org.eclipse.jface.viewers.IStructuredContentProvider"\r
bean-name="processListStructuredContentProvider" />\r
+ <reference id="processDetailContentProvider"\r
+ interface="org.eclipse.jface.viewers.ITreeContentProvider" bean-name="processDetailContentProvider" />\r
+\r
+\r
\r
<!-- TODO : what is it for ? -->\r
<list id="slcAgents" interface="org.argeo.slc.runtime.SlcAgent" />\r
<property name="tableLabelProvider" ref="processListTableLabelProvider" />
</bean>
+ <bean id="org.argeo.slc.client.ui.processDetailView" class="org.argeo.slc.client.ui.views.ProcessDetailView"
+ scope="prototype">
+ <property name="slcExecutionDao" ref="slcExecutionDao" />
+ <property name="contentProvider" ref="processDetailContentProvider" />
+ <property name="labelProvider" ref="processDetailLabelProvider" />
+ </bean>
+
+ <bean id="processDetailLabelProvider"
+ class="org.argeo.slc.client.ui.views.ProcessDetailLabelProvider"
+ scope="prototype" />
+
<bean id="org.argeo.slc.client.ui.processBuilderView" class="org.argeo.slc.client.ui.views.ProcessBuilderView"
scope="prototype">
<property name="processController" ref="processController" />
name="Process List"
restorable="true">
</view>
+ <view
+ id="org.argeo.slc.client.ui.processDetailView"
+ class="org.argeo.eclipse.spring.SpringExtensionFactory"
+ name="Process Details"
+ allowMultiple="true"
+ restorable="true">
+ </view>
<view
id="org.argeo.slc.client.ui.processBuilderView"
class="org.argeo.eclipse.spring.SpringExtensionFactory"
<extension
point="org.eclipse.ui.commands">
- <!--defaultHandler="org.argeo.slc.client.ui.commands.RefreshHandler" -->
<command
defaultHandler="org.argeo.eclipse.spring.SpringCommandHandler"
- id="org.argeo.slc.client.ui.RefreshResultList"
+ id="org.argeo.slc.client.ui.refreshResultList"
name="RefreshResultList ">
</command>
<command
defaultHandler="org.argeo.eclipse.spring.SpringCommandHandler"
- id="org.argeo.slc.client.ui.RefreshProcessList"
+ id="org.argeo.slc.client.ui.refreshProcessList"
name="RefreshProcessList ">
</command>
+ <command
+ defaultHandler="org.argeo.eclipse.spring.SpringCommandHandler"
+ id="org.argeo.slc.client.ui.displayProcessDetails"
+ name="DisplayProcessDetails">
+ <commandParameter
+ id="org.argeo.slc.client.commands.processUuid"
+ name="Process UUID">
+ </commandParameter>
+ </command>
</extension>
<extension
point="org.eclipse.ui.bindings">
<key
- commandId="org.argeo.slc.client.ui.RefreshResultList"
+ commandId="org.argeo.slc.client.ui.refreshResultList"
schemeId="org.eclipse.ui.defaultAcceleratorConfiguration"
sequence="CTRL+R">
</key>
id="slcMenu"
label="SLC">
<command
- commandId="org.argeo.slc.client.ui.RefreshResultList"
+ commandId="org.argeo.slc.client.ui.refreshResultList"
label="Refresh"
style="push"
tooltip="Refresh the result list">
<toolbar
id="org.argeo.slc.client.ui.ResultViewToolbar">
<command
- commandId="org.argeo.slc.client.ui.RefreshResultList"
+ commandId="org.argeo.slc.client.ui.refreshResultList"
icon="icons/refresh.png"
label="Refresh"
style="toggle"
--- /dev/null
+package org.argeo.slc.client.ui.commands;
+
+import org.apache.commons.logging.Log;
+import org.apache.commons.logging.LogFactory;
+import org.argeo.slc.client.ui.views.ProcessDetailView;
+import org.eclipse.core.commands.AbstractHandler;
+import org.eclipse.core.commands.ExecutionEvent;
+import org.eclipse.core.commands.ExecutionException;
+import org.eclipse.ui.handlers.HandlerUtil;
+
+/**
+ * Command handler to set visible or create a ProcessDetailView. UUID of the
+ * process is passed via command parameters.
+ *
+ * @author bsinou
+ *
+ */
+
+public class ProcessDetailsDisplayHandler extends AbstractHandler {
+ private static final Log log = LogFactory
+ .getLog(ProcessDetailsDisplayHandler.class);
+
+ public Object execute(ExecutionEvent event) throws ExecutionException {
+
+ // We pass the UUID of the process we want to display via command
+ // parameters.
+ String uuid = event
+ .getParameter("org.argeo.slc.client.commands.processUuid");
+
+ // mode = 2 : VIEW_VISIBLE, Show view mode that indicates the view
+ // should be created or made visible if already created .
+ try {
+ ProcessDetailView pView = (ProcessDetailView) HandlerUtil
+ .getActiveWorkbenchWindow(event).getActivePage()
+ .showView(ProcessDetailView.ID, "UUID-" + uuid, 2);
+ log.debug("Newly created pView : " + pView);
+ pView.setUuid(uuid);
+ log.debug("uuid set");
+ pView.retrieveResults();
+ } catch (Exception e) {
+ e.printStackTrace();
+ }
+
+ return null;
+ }
+}
try {
handlerService
.executeCommand(
- "org.argeo.slc.client.ui.RefreshResultList",
+ "org.argeo.slc.client.ui.refreshResultList",
null);
handlerService
.executeCommand(
- "org.argeo.slc.client.ui.RefreshProcessList",
+ "org.argeo.slc.client.ui.refreshProcessList",
null);
} catch (Exception e) {
public Image getImage(Object obj) {
if (obj instanceof ExecutionModulesContentProvider.AgentNode)
- return ClientUiPlugin.getDefault().getImageRegistry().get(
- "agent");
+ return ClientUiPlugin.getDefault().getImageRegistry()
+ .get("agent");
else if (obj instanceof ExecutionModulesContentProvider.ExecutionModuleNode)
- return ClientUiPlugin.getDefault().getImageRegistry().get(
- "executionModule");
+ return ClientUiPlugin.getDefault().getImageRegistry()
+ .get("executionModule");
else if (obj instanceof ExecutionModulesContentProvider.FolderNode)
- return ClientUiPlugin.getDefault().getImageRegistry().get(
- "folder");
+ return ClientUiPlugin.getDefault().getImageRegistry()
+ .get("folder");
else if (obj instanceof ExecutionModulesContentProvider.FlowNode)
- return ClientUiPlugin.getDefault().getImageRegistry().get(
- "flow");
+ return ClientUiPlugin.getDefault().getImageRegistry()
+ .get("flow");
else
- return PlatformUI.getWorkbench().getSharedImages().getImage(
- ISharedImages.IMG_OBJ_ELEMENT);
+ return PlatformUI.getWorkbench().getSharedImages()
+ .getImage(ISharedImages.IMG_OBJ_ELEMENT);
}
}
SlcExecution slcExecution = new SlcExecution();
slcExecution.setUuid(UUID.randomUUID().toString());
slcExecution.setRealizedFlows(realizedFlows);
+ slcExecution.setHost(fn.getExecutionModuleNode().getAgentNode()
+ .getAgent().toString());
processController.execute(fn.getExecutionModuleNode()
.getAgentNode().getAgent(), slcExecution);
}
--- /dev/null
+package org.argeo.slc.client.ui.views;
+
+import org.argeo.slc.process.SlcExecution;
+import org.eclipse.jface.viewers.ITableLabelProvider;
+import org.eclipse.jface.viewers.LabelProvider;
+import org.eclipse.swt.graphics.Image;
+
+/**
+ * @author bsinou
+ *
+ * Fill ProcessDetail view. Deported in an external bundle so that main
+ * slc ui bundle does not depend on DB implementation.
+ */
+public class ProcessDetailLabelProvider extends LabelProvider implements
+ ITableLabelProvider {
+ public String getColumnText(Object obj, int index) {
+ // log.debug(sessionFactory.getClass().toString());
+
+ SlcExecution se = (SlcExecution) obj;
+ switch (index) {
+
+ case 0:
+ return getText(se.getStartDate());
+ case 1:
+ return se.getHost();
+ case 2:
+ return se.getUuid();
+ case 3:
+ return se.currentStep().getType();
+ }
+ return getText(obj);
+ }
+
+ public Image getColumnImage(Object obj, int index) {
+ return null;
+ }
+
+}
--- /dev/null
+package org.argeo.slc.client.ui.views;
+
+import org.apache.commons.logging.Log;
+import org.apache.commons.logging.LogFactory;
+import org.argeo.slc.dao.process.SlcExecutionDao;
+import org.argeo.slc.process.SlcExecution;
+import org.eclipse.jface.viewers.IContentProvider;
+import org.eclipse.jface.viewers.ILabelProvider;
+import org.eclipse.jface.viewers.TreeViewer;
+import org.eclipse.swt.SWT;
+import org.eclipse.swt.widgets.Composite;
+import org.eclipse.ui.part.ViewPart;
+
+/**
+ * Multi-instance view that enables to browse the details of a given
+ * TreeTestResult
+ *
+ * @author bsinou
+ *
+ */
+
+public class ProcessDetailView extends ViewPart {
+ private final static Log log = LogFactory.getLog(ProcessDetailView.class);
+ public static final String ID = "org.argeo.slc.client.ui.processDetailView";
+
+ private TreeViewer viewer;
+
+ private String uuid;
+ private SlcExecution se;
+
+ // IoC
+ private IContentProvider contentProvider;
+ private ILabelProvider labelProvider;
+ private SlcExecutionDao slcExecutionDao;
+
+ public void createPartControl(Composite parent) {
+ // log.debug("In create part Control &&& uuid = " + uuid);
+ viewer = new TreeViewer(parent, SWT.MULTI | SWT.H_SCROLL | SWT.V_SCROLL);
+ viewer.setContentProvider(contentProvider);
+ viewer.setLabelProvider(labelProvider);
+ // viewer.setInput(getViewSite());
+ log.debug("PartControl CREATED.");
+ }
+
+ public void setFocus() {
+ viewer.getControl().setFocus();
+ }
+
+ public TreeViewer getViewer() {
+ return viewer;
+ }
+
+ public void retrieveResults() {
+ se = slcExecutionDao.getSlcExecution(uuid);
+ log.debug("========= Se : " + se);
+ viewer.setInput(se);
+ log.debug("Input SET");
+ }
+
+ public void setUuid(String uuid) {
+ this.uuid = uuid;
+ }
+
+ // IoC
+ public void setContentProvider(IContentProvider contentProvider) {
+ this.contentProvider = contentProvider;
+ }
+
+ public void setLabelProvider(ILabelProvider labelProvider) {
+ this.labelProvider = labelProvider;
+ }
+
+ public void setSlcExecutionDao(SlcExecutionDao slcExecutionDao) {
+ this.slcExecutionDao = slcExecutionDao;
+ }
+
+}
\ No newline at end of file
package org.argeo.slc.client.ui.views;
+import java.util.ArrayList;
+
+import org.apache.commons.logging.Log;
+import org.apache.commons.logging.LogFactory;
+import org.argeo.slc.SlcException;
+import org.argeo.slc.client.ui.ClientUiPlugin;
import org.argeo.slc.dao.process.SlcExecutionDao;
+import org.argeo.slc.process.SlcExecution;
+import org.eclipse.core.commands.Command;
+import org.eclipse.core.commands.IParameter;
+import org.eclipse.core.commands.Parameterization;
+import org.eclipse.core.commands.ParameterizedCommand;
+import org.eclipse.jface.viewers.DoubleClickEvent;
+import org.eclipse.jface.viewers.IDoubleClickListener;
import org.eclipse.jface.viewers.IStructuredContentProvider;
+import org.eclipse.jface.viewers.IStructuredSelection;
import org.eclipse.jface.viewers.ITableLabelProvider;
import org.eclipse.jface.viewers.TableViewer;
import org.eclipse.swt.SWT;
import org.eclipse.swt.widgets.Composite;
import org.eclipse.swt.widgets.Table;
import org.eclipse.swt.widgets.TableColumn;
+import org.eclipse.ui.IWorkbench;
+import org.eclipse.ui.IWorkbenchWindow;
+import org.eclipse.ui.commands.ICommandService;
+import org.eclipse.ui.handlers.IHandlerService;
import org.eclipse.ui.part.ViewPart;
+/**
+ * This class display the list of all processes that have run in the
+ * corresponding agent. Currently, the local agent.
+ *
+ * @author bsinou
+ *
+ */
public class ProcessListView extends ViewPart {
- // private final static Log log = LogFactory.getLog(ProcessListView.class);
+ private final static Log log = LogFactory.getLog(ProcessListView.class);
public static final String ID = "org.argeo.slc.client.ui.processListView";
viewer.setLabelProvider(tableLabelProvider);
viewer.setContentProvider(structuredContentProvider);
viewer.setInput(getViewSite());
+ viewer.addDoubleClickListener(new ViewDoubleClickListener());
+
}
protected Table createTable(Composite parent) {
viewer.setInput(slcExecutionDao.listSlcExecutions());
}
+ // Handle Events
+ class ViewDoubleClickListener implements IDoubleClickListener {
+ public void doubleClick(DoubleClickEvent evt) {
+ Object obj = ((IStructuredSelection) evt.getSelection())
+ .getFirstElement();
+
+ if (obj instanceof SlcExecution) {
+ SlcExecution se = (SlcExecution) obj;
+ log.debug("DOUBLE CLICK ON process d'UUID" + se.getUuid());
+
+ // ClientUiPlugin.getDefault().getWorkbench().getDisplay()
+ // .syncExec(new Runnable() {
+ // public void run() {
+ IWorkbench iw = ClientUiPlugin.getDefault().getWorkbench();
+ IHandlerService handlerService = (IHandlerService) iw
+ .getService(IHandlerService.class);
+ try {
+ // get the command from plugin.xml
+ IWorkbenchWindow window = iw.getActiveWorkbenchWindow();
+ ICommandService cmdService = (ICommandService) window
+ .getService(ICommandService.class);
+ Command cmd = cmdService
+ .getCommand("org.argeo.slc.client.ui.displayProcessDetails");
+
+ // log.debug("cmd : " + cmd);
+ ArrayList<Parameterization> parameters = new ArrayList<Parameterization>();
+
+ // get the parameter
+ IParameter iparam = cmd
+ .getParameter("org.argeo.slc.client.commands.processUuid");
+ Parameterization params = new Parameterization(iparam,
+ se.getUuid()); // "testUUID");//
+ parameters.add(params);
+
+ // build the parameterized command
+ ParameterizedCommand pc = new ParameterizedCommand(cmd,
+ parameters.toArray(new Parameterization[parameters
+ .size()]));
+
+ // execute the command
+ handlerService = (IHandlerService) window
+ .getService(IHandlerService.class);
+ handlerService.executeCommand(pc, null);
+
+ } catch (Exception e) {
+ e.printStackTrace();
+ throw new SlcException("Problem while rendering result. "
+ + e.getMessage());
+ }
+ }
+ }
+ }
+
// IoC
public void setSlcExecutionDao(SlcExecutionDao slcExecutionDao) {
this.slcExecutionDao = slcExecutionDao;
projects / gpl / argeo-slc.git / commitdiff