From 5e4034b5cba89460a62fa958fc78c2b85acb3d5f Mon Sep 17 00:00:00 2001 From: Andrew Branson Date: Tue, 7 Oct 2014 09:18:33 +0200 Subject: Repackage to org.cristalise --- .../lifecycle/desc/ActivitySlotDefRenderer.java | 72 ++++++ .../lifecycle/desc/CompActDefOutcomeHandler.java | 242 +++++++++++++++++++++ .../lifecycle/desc/ElemActDefOutcomeHandler.java | 228 +++++++++++++++++++ .../gui/lifecycle/desc/SplitJoinDefRenderer.java | 139 ++++++++++++ .../gui/lifecycle/desc/WfDefGraphPanel.java | 60 +++++ .../lifecycle/desc/WfDirectedEdgeDefRenderer.java | 135 ++++++++++++ .../gui/lifecycle/desc/WfEdgeDefFactory.java | 30 +++ .../gui/lifecycle/desc/WfVertexDefFactory.java | 97 +++++++++ .../gui/lifecycle/desc/WfVertexDefRenderer.java | 31 +++ 9 files changed, 1034 insertions(+) create mode 100644 src/main/java/org/cristalise/gui/lifecycle/desc/ActivitySlotDefRenderer.java create mode 100644 src/main/java/org/cristalise/gui/lifecycle/desc/CompActDefOutcomeHandler.java create mode 100644 src/main/java/org/cristalise/gui/lifecycle/desc/ElemActDefOutcomeHandler.java create mode 100644 src/main/java/org/cristalise/gui/lifecycle/desc/SplitJoinDefRenderer.java create mode 100644 src/main/java/org/cristalise/gui/lifecycle/desc/WfDefGraphPanel.java create mode 100644 src/main/java/org/cristalise/gui/lifecycle/desc/WfDirectedEdgeDefRenderer.java create mode 100644 src/main/java/org/cristalise/gui/lifecycle/desc/WfEdgeDefFactory.java create mode 100644 src/main/java/org/cristalise/gui/lifecycle/desc/WfVertexDefFactory.java create mode 100644 src/main/java/org/cristalise/gui/lifecycle/desc/WfVertexDefRenderer.java (limited to 'src/main/java/org/cristalise/gui/lifecycle/desc') diff --git a/src/main/java/org/cristalise/gui/lifecycle/desc/ActivitySlotDefRenderer.java b/src/main/java/org/cristalise/gui/lifecycle/desc/ActivitySlotDefRenderer.java new file mode 100644 index 0000000..c15cf17 --- /dev/null +++ b/src/main/java/org/cristalise/gui/lifecycle/desc/ActivitySlotDefRenderer.java @@ -0,0 +1,72 @@ +package org.cristalise.gui.lifecycle.desc; + +import java.awt.Color; +import java.awt.FontMetrics; +import java.awt.Graphics2D; +import java.awt.Paint; + +import org.cristalise.gui.graph.view.VertexRenderer; +import org.cristalise.kernel.graph.model.GraphPoint; +import org.cristalise.kernel.graph.model.Vertex; +import org.cristalise.kernel.lifecycle.ActivitySlotDef; +import org.cristalise.kernel.utils.Language; + + +public class ActivitySlotDefRenderer implements VertexRenderer +{ + private Paint mInactivePaint = new Color(255, 255, 255); + private Paint mErrorPaint = new Color( 255, 50, 0 ); + private Paint mCompositePaint= new Color(200, 200, 255); + private Paint mTextPaint = Color.black; + + + @Override + public void draw( Graphics2D g2d, Vertex vertex) + { + ActivitySlotDef activitySlotDef = ( ActivitySlotDef )vertex; + boolean hasError = activitySlotDef.verify(); + boolean isComposite = false; + isComposite = activitySlotDef.getIsComposite(); + GraphPoint centrePoint = activitySlotDef.getCentrePoint(); + int vertexHeight = activitySlotDef.getHeight(); + int vertexWidth = activitySlotDef.getWidth(); + + String[] linesOfText = new String[2+(hasError?0:1)]; + FontMetrics metrics = g2d.getFontMetrics(); + int lineWidth = 0; + int lineHeight = metrics.getHeight(); + int linesHeight = lineHeight * linesOfText.length; + int linesStartY = centrePoint.y - linesHeight / 2 + lineHeight * 2 / 3; + int x = 0; + int y = 0; + int i = 0; + + linesOfText[0]="("+activitySlotDef.getActivityDef()+")"; + linesOfText[1]=(String)activitySlotDef.getProperties().get("Name"); + + if (!hasError)linesOfText[2]=Language.translate(activitySlotDef.getErrors()); + + g2d.setPaint( !hasError ? mErrorPaint : isComposite ? mCompositePaint : mInactivePaint ); + g2d.fill3DRect + ( + centrePoint.x - vertexWidth / 2, + centrePoint.y - vertexHeight / 2, + vertexWidth, + vertexHeight, + true + ); + + g2d.setPaint( mTextPaint ); + + // Draw the lines of text + for ( i = 0; i < linesOfText.length; i++ ) + { + if (linesOfText[i] == null) linesOfText[i] = ""; + lineWidth = metrics.stringWidth( linesOfText[ i ] ); + x = centrePoint.x - lineWidth / 2; + y = linesStartY + i * lineHeight; + g2d.drawString( linesOfText[ i ], x, y ); + } + } +} + diff --git a/src/main/java/org/cristalise/gui/lifecycle/desc/CompActDefOutcomeHandler.java b/src/main/java/org/cristalise/gui/lifecycle/desc/CompActDefOutcomeHandler.java new file mode 100644 index 0000000..eabc85b --- /dev/null +++ b/src/main/java/org/cristalise/gui/lifecycle/desc/CompActDefOutcomeHandler.java @@ -0,0 +1,242 @@ +package org.cristalise.gui.lifecycle.desc; + +import java.awt.GridBagConstraints; +import java.awt.GridBagLayout; +import java.awt.event.ActionEvent; +import java.awt.event.ActionListener; +import java.io.BufferedWriter; +import java.io.File; +import java.io.FileWriter; + +import javax.swing.JButton; +import javax.swing.JFileChooser; +import javax.swing.JPanel; +import javax.swing.JSplitPane; + +import org.cristalise.gui.ImageLoader; +import org.cristalise.gui.MainFrame; +import org.cristalise.gui.graph.view.EditorPanel; +import org.cristalise.gui.graph.view.VertexPropertyPanel; +import org.cristalise.gui.lifecycle.instance.FindActDefPanel; +import org.cristalise.gui.tabs.outcome.InvalidOutcomeException; +import org.cristalise.gui.tabs.outcome.InvalidSchemaException; +import org.cristalise.gui.tabs.outcome.OutcomeException; +import org.cristalise.gui.tabs.outcome.OutcomeHandler; +import org.cristalise.gui.tabs.outcome.OutcomeNotInitialisedException; +import org.cristalise.kernel.graph.layout.DefaultGraphLayoutGenerator; +import org.cristalise.kernel.lifecycle.CompositeActivityDef; +import org.cristalise.kernel.lifecycle.WfVertexDefOutlineCreator; +import org.cristalise.kernel.process.Gateway; +import org.cristalise.kernel.utils.FileStringUtility; +import org.cristalise.kernel.utils.Logger; + + +/************************************************************************** + * + * $Revision: 1.14 $ + * $Date: 2005/09/07 13:46:31 $ + * + * Copyright (C) 2003 CERN - European Organization for Nuclear Research + * All rights reserved. + **************************************************************************/ + +public class CompActDefOutcomeHandler + extends JPanel + implements OutcomeHandler { + + protected JButton mLoadButton = new JButton(ImageLoader.findImage("graph/load.png")); + protected JButton mLayoutButton = new JButton(ImageLoader.findImage("graph/autolayout.png")); + protected JButton[] mOtherToolBarButtons = { mLayoutButton, mLoadButton }; + + protected CompositeActivityDef mCompActDef = null; + protected WfEdgeDefFactory mWfEdgeDefFactory = new WfEdgeDefFactory(); + protected WfVertexDefFactory mWfVertexDefFactory = new WfVertexDefFactory(); + + protected EditorPanel mEditorPanel; + protected VertexPropertyPanel mPropertyPanel; + protected JSplitPane mSplitPane; + boolean unsaved; + + public CompActDefOutcomeHandler() { + super(); + mPropertyPanel = loadPropertyPanel(); + mPropertyPanel.createLayout(new FindActDefPanel()); + mEditorPanel = + new EditorPanel( + mWfEdgeDefFactory, + mWfVertexDefFactory, + new WfVertexDefOutlineCreator(), + true, + mOtherToolBarButtons, + new WfDefGraphPanel(new WfDirectedEdgeDefRenderer(), + new WfVertexDefRenderer())); + } + + protected void createLayout() + { + mLoadButton.setToolTipText("Load from local file"); + mLayoutButton.setToolTipText("Auto-Layout"); + + // Add the editor pane + GridBagLayout gridbag = new GridBagLayout(); + setLayout(gridbag); + GridBagConstraints c = new GridBagConstraints(); + c.gridx = 0; + c.gridy = 1; + c.fill = GridBagConstraints.BOTH; + c.weighty = 2.0; + c.weightx = 2.0; + mSplitPane = new JSplitPane(JSplitPane.HORIZONTAL_SPLIT, mEditorPanel, mPropertyPanel); + mSplitPane.setDividerSize(5); + gridbag.setConstraints(mSplitPane, c); + add(mSplitPane); + revalidate(); + } + + protected void createListeners() + { + mLoadButton.addActionListener(new ActionListener() { + @Override + public void actionPerformed(ActionEvent ae) { + File selectedFile = null; + + int returnValue = MainFrame.xmlChooser.showOpenDialog(null); + + switch (returnValue) + { + case JFileChooser.APPROVE_OPTION : + selectedFile = MainFrame.xmlChooser.getSelectedFile(); + try { + String newWf = FileStringUtility.file2String(selectedFile); + setOutcome(newWf); + setUpGraphEditor(); + } catch (Exception e) { + MainFrame.exceptionDialog(e); + } + case JFileChooser.CANCEL_OPTION : + case JFileChooser.ERROR_OPTION : + + default : + } + } + }); + + mLayoutButton.addActionListener(new ActionListener() { + @Override + public void actionPerformed(ActionEvent ae) { + DefaultGraphLayoutGenerator.layoutGraph(mEditorPanel.mGraphModelManager.getModel()); + } + }); + } + + public void setUpGraphEditor() { + mEditorPanel.mGraphModelManager.setModel(mCompActDef.getChildrenGraphModel()); + // Give the editor panel the edge and vertex types + mEditorPanel.updateVertexTypes(mCompActDef.getVertexTypeNameAndConstructionInfo()); + mEditorPanel.updateEdgeTypes(mCompActDef.getEdgeTypeNameAndConstructionInfo()); + mEditorPanel.enterSelectMode(); + mWfVertexDefFactory.setCreationContext(mCompActDef); + } + + /** + * + */ + @Override + public void setOutcome(String outcome) throws InvalidOutcomeException { + try { + CompositeActivityDef newAct = (CompositeActivityDef)Gateway.getMarshaller().unmarshall(outcome); + if (mCompActDef != null) + newAct.setName(mCompActDef.getName()); + mCompActDef = newAct; + } catch (Exception ex) { + Logger.error(ex); + throw new InvalidOutcomeException(ex.getMessage()); + } + } + /** + * + */ + @Override + public void setDescription(String description) + throws InvalidSchemaException { + // ignore - always the same + } + /** + * + */ + @Override + public void setReadOnly(boolean readOnly) { + mLayoutButton.setEnabled(!readOnly); + mLoadButton.setEnabled(!readOnly); + mEditorPanel.setEditable(!readOnly); + mPropertyPanel.setEditable(!readOnly); + } + /** + * + */ + @Override + public JPanel getPanel() throws OutcomeNotInitialisedException { + return this; + } + /** + * + */ + @Override + public String getOutcome() throws OutcomeException { + if (!mCompActDef.verify()) + throw new OutcomeException(mCompActDef.getErrors()); + try { + return Gateway.getMarshaller().marshall(mCompActDef); + } catch (Exception ex) { + throw new OutcomeException(ex.getMessage()); + } + } + /** + * + */ + @Override + public void run() { + Thread.currentThread().setName("Composite Act Def Viewer"); + createLayout(); + createListeners(); + mPropertyPanel.setGraphModelManager(mEditorPanel.mGraphModelManager); + setUpGraphEditor(); + } + + public VertexPropertyPanel loadPropertyPanel() + { + String wfPanelClass = Gateway.getProperties().getString("WfPropertyPanel"); + if (wfPanelClass != null) { + try { + return (VertexPropertyPanel)Gateway.getProperties().getInstance("WfPropertyPanel"); + } catch (Exception ex) { + Logger.error("Could not load wf props panel:"+wfPanelClass); + Logger.error(ex); + } + } + return new VertexPropertyPanel(); + } + + @Override + public boolean isUnsaved() { + return unsaved; + } + + @Override + public void saved() { + unsaved = false; + } + + @Override + public void export(File targetFile) throws Exception { + //Make sure module structure is present + File parentDir = targetFile.getParentFile(); + FileStringUtility.createNewDir(parentDir.getAbsolutePath()+"/CA"); + FileStringUtility.createNewDir(parentDir.getAbsolutePath()+"/EA"); + FileStringUtility.createNewDir(parentDir.getAbsolutePath()+"/OD"); + FileStringUtility.createNewDir(parentDir.getAbsolutePath()+"/SC"); + BufferedWriter imports = new BufferedWriter(new FileWriter(new File(parentDir, mCompActDef.getActName()+"Imports.xml"))); + ElemActDefOutcomeHandler.exportAct(targetFile.getParentFile(), imports, mCompActDef); + imports.close(); + } +} diff --git a/src/main/java/org/cristalise/gui/lifecycle/desc/ElemActDefOutcomeHandler.java b/src/main/java/org/cristalise/gui/lifecycle/desc/ElemActDefOutcomeHandler.java new file mode 100644 index 0000000..985ce0a --- /dev/null +++ b/src/main/java/org/cristalise/gui/lifecycle/desc/ElemActDefOutcomeHandler.java @@ -0,0 +1,228 @@ +package org.cristalise.gui.lifecycle.desc; + +import java.io.BufferedWriter; +import java.io.File; + +import javax.swing.JOptionPane; +import javax.swing.JPanel; + +import org.cristalise.gui.MainFrame; +import org.cristalise.gui.graph.view.VertexPropertyPanel; +import org.cristalise.gui.tabs.outcome.InvalidOutcomeException; +import org.cristalise.gui.tabs.outcome.InvalidSchemaException; +import org.cristalise.gui.tabs.outcome.OutcomeException; +import org.cristalise.gui.tabs.outcome.OutcomeHandler; +import org.cristalise.gui.tabs.outcome.OutcomeNotInitialisedException; +import org.cristalise.kernel.common.ObjectNotFoundException; +import org.cristalise.kernel.entity.agent.Job; +import org.cristalise.kernel.entity.proxy.ItemProxy; +import org.cristalise.kernel.graph.model.GraphableVertex; +import org.cristalise.kernel.lifecycle.ActivityDef; +import org.cristalise.kernel.lifecycle.ActivitySlotDef; +import org.cristalise.kernel.lifecycle.CompositeActivityDef; +import org.cristalise.kernel.persistency.ClusterStorage; +import org.cristalise.kernel.persistency.outcome.Viewpoint; +import org.cristalise.kernel.process.Gateway; +import org.cristalise.kernel.utils.FileStringUtility; +import org.cristalise.kernel.utils.LocalObjectLoader; +import org.cristalise.kernel.utils.Logger; + + +/************************************************************************** + * + * $Revision: 1.5 $ + * $Date: 2005/10/05 07:39:37 $ + * + * Copyright (C) 2003 CERN - European Organization for Nuclear Research + * All rights reserved. + **************************************************************************/ + +public class ElemActDefOutcomeHandler extends VertexPropertyPanel implements OutcomeHandler { + + ActivityDef act; + boolean unsaved; + public ElemActDefOutcomeHandler() { + super(); + createLayout(null); + } + + /** + * + */ + @Override + public void setOutcome(String outcome) throws InvalidOutcomeException { + try { + act = (ActivityDef)Gateway.getMarshaller().unmarshall(outcome); + setVertex(act); + } catch (Exception ex) { + Logger.error(ex); + throw new InvalidOutcomeException(); + } + } + + /** + * + */ + @Override + public void setDescription(String description) + throws InvalidSchemaException { + // ignore + } + + /** + * + */ + @Override + public void setReadOnly(boolean readOnly) { + setEditable(!readOnly); + + } + + /** + * + */ + @Override + public JPanel getPanel() throws OutcomeNotInitialisedException { + return this; + } + + /** + * + */ + @Override + public String getOutcome() throws OutcomeException { + try { + return Gateway.getMarshaller().marshall(act); + } catch (Exception ex) { + Logger.error(ex); + throw new OutcomeException(); + } + } + + /** + * + */ + @Override + public void run() { + validate(); + } + + @Override + public boolean isUnsaved() { + return unsaved; + } + + @Override + public void saved() { + unsaved = false; + } + + @Override + public void export(File targetFile) throws Exception { + exportAct(targetFile.getParentFile(), null, act); + } + + public static void exportAct(File dir, BufferedWriter imports, ActivityDef actDef) throws Exception { + + // Export associated schema + exportSchema((String)actDef.getProperties().get("SchemaType"), actDef.getProperties().get("SchemaVersion"), imports, new File(dir, "OD")); + // Export associated script + exportScript((String)actDef.getProperties().get("ScriptName"), actDef.getProperties().get("ScriptVersion"), imports, new File(dir, "SC")); + + //Export child act if composite + if (actDef instanceof CompositeActivityDef) { + CompositeActivityDef compActDef = (CompositeActivityDef)actDef; + for (int i=0; iboot/CA/"+compActDef.getActName()+".xml\n"); + } + } + else { + FileStringUtility.string2File(new File(new File(dir, "EA"), actDef.getActName()+".xml"), Gateway.getMarshaller().marshall(actDef)); + if (imports!=null) imports.write("boot/EA/"+actDef.getActName()+".xml\n"); + } + } + + private static void resolveRealVersion(ActivitySlotDef childDef) throws ObjectNotFoundException { + String defName = childDef.getActName(); + ItemProxy actDefItem = LocalObjectLoader.loadLocalObjectDef("/desc/ActivityDesc/", defName); + String actType = actDefItem.getProperty("Complexity"); + Viewpoint last = actDefItem.getViewpoint( actType + "ActivityDef", "last"); + String[] viewpoints = actDefItem.getContents(ClusterStorage.VIEWPOINT+"/"+actType + "ActivityDef"); + for (String viewName : viewpoints) { + try { + Integer.parseInt(viewName); + } catch (NumberFormatException e) { + continue; // only count integer viewnames + } + Viewpoint thisView = actDefItem.getViewpoint(actType + "ActivityDef", viewName); + if (thisView.getEventId() == last.getEventId()) { + JOptionPane.showMessageDialog(null, defName+" defined as 'last'. Will use view "+viewName+" instead"); + childDef.getProperties().put("Version", viewName); + return; + } + } + JOptionPane.showMessageDialog(null, "Last view for "+defName+" has not been materialized. Executing CreateFromLast"); + try { + Job createJob = actDefItem.getJobByName("AssignNewActivityVersionFromLast", MainFrame.userAgent); + MainFrame.userAgent.execute(createJob); + } catch (Exception e) { + Logger.error(e); + throw new ObjectNotFoundException("Could not create new version of "+defName+" from last"); + } + resolveRealVersion(childDef); + } + + public static void exportScript(String name, Object version, BufferedWriter imports, File dir) { + if (name == null || name.length()==0 || name.contains(":")) return; + try { + int intVersion; + if (version instanceof String) intVersion = Integer.parseInt((String)version); + else if (version instanceof Integer) intVersion = ((Integer)version).intValue(); + else return; + + FileStringUtility.string2File(new File(dir, name+".xml"), + LocalObjectLoader.getScript(name, intVersion)); + if (imports!=null) imports.write("boot/SC/"+name+".xml\n"); + } catch (NumberFormatException ex) { + JOptionPane.showMessageDialog(null, "Invalid version number in script version:"+version); + } catch (Exception ex) { + Logger.error(ex); + JOptionPane.showMessageDialog(null, "Could not export script "+name+"_"+version, "Error", JOptionPane.ERROR_MESSAGE); + } + } + + public static void exportSchema(String name, Object version, BufferedWriter imports, File dir) { + if (name == null || name.length()==0) return; + try { + int intVersion; + if (version instanceof String) intVersion = Integer.parseInt((String)version); + else if (version instanceof Integer) intVersion = ((Integer)version).intValue(); + else return; + FileStringUtility.string2File(new File(dir, name+".xsd"), + LocalObjectLoader.getSchema(name, intVersion).schema); + if (imports!=null) imports.write("boot/OD/"+name+".xsd\n"); + } catch (NumberFormatException ex) { + JOptionPane.showMessageDialog(null, "Invalid version number in script version:"+version); + } catch (Exception ex) { + Logger.error(ex); + JOptionPane.showMessageDialog(null, "Could not export schema "+name+"_"+version, "Error", JOptionPane.ERROR_MESSAGE); + } + } +} diff --git a/src/main/java/org/cristalise/gui/lifecycle/desc/SplitJoinDefRenderer.java b/src/main/java/org/cristalise/gui/lifecycle/desc/SplitJoinDefRenderer.java new file mode 100644 index 0000000..65d59b2 --- /dev/null +++ b/src/main/java/org/cristalise/gui/lifecycle/desc/SplitJoinDefRenderer.java @@ -0,0 +1,139 @@ +package org.cristalise.gui.lifecycle.desc; + +import java.awt.Color; +import java.awt.FontMetrics; +import java.awt.Graphics2D; +import java.awt.Paint; + +import org.cristalise.gui.graph.view.VertexRenderer; +import org.cristalise.kernel.graph.model.GraphPoint; +import org.cristalise.kernel.graph.model.Vertex; +import org.cristalise.kernel.lifecycle.AndSplitDef; +import org.cristalise.kernel.lifecycle.JoinDef; +import org.cristalise.kernel.lifecycle.LoopDef; +import org.cristalise.kernel.lifecycle.OrSplitDef; +import org.cristalise.kernel.lifecycle.WfVertexDef; +import org.cristalise.kernel.lifecycle.XOrSplitDef; +import org.cristalise.kernel.utils.Language; + + + +public class SplitJoinDefRenderer implements VertexRenderer +{ + private Paint mTextPaint = Color.black; + private Paint mBoxPaint = new Color( 204, 204, 204 ); + private Paint mErrorPaint = new Color( 255, 50, 0 ); + private boolean mTextOffsetsNotInitialised = true; + private int mTextYOffset = 0; + private String mAndText = "And"; + private int mAndTextXOffset = 0; + private String mOrText = "Or"; + private int mOrTextXOffset = 0; + private String mXOrText = "XOr"; + private int mXOrTextXOffset = 0; + private String mJoinText = "Join"; + private int mJoinTextXOffset = 0; + private String mLoopText = "Loop"; + private int mLoopTextXOffset = 0; + private String mRouteText = ""; + private int mRouteTextXOffset = 0; + private String mXXXText = "XXX"; + private int mXXXTextXOffset = 0; + + @Override + public void draw( Graphics2D g2d, Vertex vertex) + { + GraphPoint centrePoint = vertex.getCentrePoint(); + String text = null; + int textXOffset = 0; + int vertexHeight = vertex.getHeight(); + int vertexWidth = vertex.getWidth(); + boolean hasError = !((WfVertexDef)vertex).verify(); + + + if ( mTextOffsetsNotInitialised ) + { + initialiseTextOffsets( g2d ); + mTextOffsetsNotInitialised = false; + } + if ( vertex instanceof LoopDef ) + { + text = Language.translate(mLoopText); + textXOffset = mLoopTextXOffset; + } + else if ( vertex instanceof XOrSplitDef ) + { + text = Language.translate(mXOrText); + textXOffset = mXOrTextXOffset; + } + else if ( vertex instanceof OrSplitDef ) + { + text = Language.translate(mOrText); + textXOffset = mOrTextXOffset; + } + else if ( vertex instanceof AndSplitDef ) + { + text = Language.translate(mAndText); + textXOffset = mAndTextXOffset; + } + else if ( vertex instanceof JoinDef) + { + String type= (String)((JoinDef)vertex).getProperties().get("Type"); + if (type!=null && type.equals("Route")) + { + text = mRouteText; + textXOffset = mRouteTextXOffset; + } + else + { + text = Language.translate(mJoinText); + textXOffset = mJoinTextXOffset; + } + } + else + { + text = mXXXText; + textXOffset = mXXXTextXOffset; + } + + + g2d.setPaint( hasError ? mErrorPaint : mBoxPaint ); + g2d.fillRect + ( + centrePoint.x - vertexWidth / 2, + centrePoint.y - vertexHeight / 2, + vertexWidth, + vertexHeight + ); + g2d.setPaint( mTextPaint ); + g2d.drawRect + ( + centrePoint.x - vertexWidth / 2, + centrePoint.y - vertexHeight / 2, + vertexWidth, + vertexHeight + ); + g2d.drawString( text, centrePoint.x - textXOffset, centrePoint.y + mTextYOffset ); + if (hasError) { + g2d.setPaint( mErrorPaint ); + String errors = Language.translate(((WfVertexDef)vertex).getErrors()); + int errorWidth = g2d.getFontMetrics().stringWidth( errors ); + g2d.drawString( errors, centrePoint.x - ( errorWidth / 2), centrePoint.y + vertexHeight ); + } + } + + private void initialiseTextOffsets( Graphics2D g2d ) + { + FontMetrics metrics = g2d.getFontMetrics(); + + + mTextYOffset = metrics.getHeight() / 3; + mAndTextXOffset = metrics.stringWidth( Language.translate(mAndText) ) / 2; + mOrTextXOffset = metrics.stringWidth( Language.translate(mOrText) ) / 2; + mXOrTextXOffset = metrics.stringWidth( Language.translate(mXOrText) ) / 2; + mJoinTextXOffset = metrics.stringWidth( Language.translate(mJoinText) ) / 2; + mLoopTextXOffset = metrics.stringWidth( Language.translate(mJoinText) ) / 2; + mRouteTextXOffset = metrics.stringWidth( Language.translate(mRouteText) ) / 2; + } +} + diff --git a/src/main/java/org/cristalise/gui/lifecycle/desc/WfDefGraphPanel.java b/src/main/java/org/cristalise/gui/lifecycle/desc/WfDefGraphPanel.java new file mode 100644 index 0000000..2ad87b2 --- /dev/null +++ b/src/main/java/org/cristalise/gui/lifecycle/desc/WfDefGraphPanel.java @@ -0,0 +1,60 @@ +/*Created on 21 nov. 2003 */ +package org.cristalise.gui.lifecycle.desc; + +import java.awt.Graphics2D; + +import org.cristalise.gui.graph.view.DirectedEdgeRenderer; +import org.cristalise.gui.graph.view.GraphPanel; +import org.cristalise.gui.graph.view.VertexRenderer; +import org.cristalise.kernel.graph.model.DirectedEdge; +import org.cristalise.kernel.graph.model.GraphPoint; +import org.cristalise.kernel.lifecycle.NextDef; + + +/** @author XSeb74*/ +public class WfDefGraphPanel extends GraphPanel +{ + public WfDefGraphPanel(DirectedEdgeRenderer d,VertexRenderer v) + { + super(d,v); + } + // Draws the highlight of the specified edge + @Override + protected void drawEdgeHighlight(Graphics2D g2d, DirectedEdge edge) + { + GraphPoint originPoint = edge.getOriginPoint(); + GraphPoint terminusPoint = edge.getTerminusPoint(); + GraphPoint midPoint = new GraphPoint(); + + if ("Straight".equals(((NextDef)edge).getProperties().get("Type")) || ((NextDef)edge).getProperties().get("Type") == null) + { + midPoint.x = originPoint.x + (terminusPoint.x - originPoint.x) / 2; + midPoint.y = originPoint.y + (terminusPoint.y - originPoint.y) / 2; + } + else if (("Broken +".equals(((NextDef)edge).getProperties().get("Type")))) + { + midPoint.x = (originPoint.x + terminusPoint.x) / 2; + midPoint.y = (originPoint.y + terminusPoint.y) / 2; + } + else if (("Broken -".equals(((NextDef)edge).getProperties().get("Type")))) + { + boolean arrowOnY = !(originPoint.y - terminusPoint.y < 60 && originPoint.y - terminusPoint.y > -60); + midPoint.x = arrowOnY ? terminusPoint.x : (originPoint.x + terminusPoint.x) / 2; + midPoint.y = arrowOnY ? (originPoint.y + terminusPoint.y) / 2 : originPoint.y; + } + else if (("Broken |".equals(((NextDef)edge).getProperties().get("Type")))) + { + boolean arrowOnY = !(originPoint.y - terminusPoint.y < 60 && originPoint.y - terminusPoint.y > -60); + midPoint.x = arrowOnY ? originPoint.x : (originPoint.x + terminusPoint.x) / 2; + midPoint.y = arrowOnY ? (originPoint.y + terminusPoint.y) / 2 : terminusPoint.y; + } + int minX = midPoint.x - 10; + int minY = midPoint.y - 10; + int maxX = midPoint.x + 10; + int maxY = midPoint.y + 10; + g2d.drawLine(minX, minY, maxX, minY); + g2d.drawLine(maxX, minY, maxX, maxY); + g2d.drawLine(maxX, maxY, minX, maxY); + g2d.drawLine(minX, maxY, minX, minY); + } +} diff --git a/src/main/java/org/cristalise/gui/lifecycle/desc/WfDirectedEdgeDefRenderer.java b/src/main/java/org/cristalise/gui/lifecycle/desc/WfDirectedEdgeDefRenderer.java new file mode 100644 index 0000000..80a67a4 --- /dev/null +++ b/src/main/java/org/cristalise/gui/lifecycle/desc/WfDirectedEdgeDefRenderer.java @@ -0,0 +1,135 @@ +package org.cristalise.gui.lifecycle.desc; +import java.awt.Color; +import java.awt.Graphics2D; +import java.awt.Shape; +import java.awt.geom.AffineTransform; +import java.awt.geom.GeneralPath; + +import org.cristalise.gui.graph.view.DirectedEdgeRenderer; +import org.cristalise.kernel.graph.model.DirectedEdge; +import org.cristalise.kernel.graph.model.GraphPoint; +import org.cristalise.kernel.lifecycle.NextDef; + +public class WfDirectedEdgeDefRenderer implements DirectedEdgeRenderer +{ + private GeneralPath mArrowTemplate = new GeneralPath(); + public WfDirectedEdgeDefRenderer() + { + mArrowTemplate.moveTo(-5, 5); + mArrowTemplate.lineTo(0, 0); + mArrowTemplate.lineTo(5, 5); + } + @Override + public void draw(Graphics2D g2d, DirectedEdge directedEdge) + { + GraphPoint originPoint = directedEdge.getOriginPoint(); + GraphPoint terminusPoint = directedEdge.getTerminusPoint(); + GraphPoint midPoint = new GraphPoint(); + AffineTransform transform = new AffineTransform(); + Shape arrow = null; + NextDef nextDef = (NextDef) directedEdge; + boolean hasError = !nextDef.verify(); + String text = (String) nextDef.getProperties().get("Alias"); + g2d.setPaint(hasError ? Color.red : Color.black); + if (("Broken +".equals(nextDef.getProperties().get("Type")))) + { + g2d.drawLine(originPoint.x, originPoint.y, originPoint.x, (originPoint.y + terminusPoint.y) / 2); + g2d.drawLine(originPoint.x, (originPoint.y + terminusPoint.y) / 2, terminusPoint.x, (originPoint.y + terminusPoint.y) / 2); + g2d.drawLine(terminusPoint.x, (originPoint.y + terminusPoint.y) / 2, terminusPoint.x, terminusPoint.y); + midPoint.x = (originPoint.x + terminusPoint.x) / 2; + midPoint.y = (originPoint.y + terminusPoint.y) / 2; + transform.translate(midPoint.x, midPoint.y); + transform.rotate( + calcArrowAngle( + originPoint.x, + originPoint.x - terminusPoint.x > -5 + && originPoint.x - terminusPoint.x < 5 ? originPoint.y : (originPoint.y + terminusPoint.y) / 2, + terminusPoint.x, + originPoint.x - terminusPoint.x > -5 + && originPoint.x - terminusPoint.x < 5 ? terminusPoint.y : (originPoint.y + terminusPoint.y) / 2)); + } + else if (("Broken -".equals(nextDef.getProperties().get("Type")))) + { + g2d.drawLine(originPoint.x, originPoint.y, terminusPoint.x, originPoint.y); + g2d.drawLine(terminusPoint.x, originPoint.y, terminusPoint.x, terminusPoint.y); + boolean arrowOnY = !(originPoint.y - terminusPoint.y < 60 && originPoint.y - terminusPoint.y > -60); + midPoint.x = arrowOnY ? terminusPoint.x : (originPoint.x + terminusPoint.x) / 2; + midPoint.y = arrowOnY ? (originPoint.y + terminusPoint.y) / 2 : originPoint.y; + transform.translate(midPoint.x, midPoint.y); + transform + .rotate( + calcArrowAngle( + arrowOnY ? terminusPoint.x : originPoint.x, + arrowOnY ? originPoint.y : originPoint.y, + arrowOnY ? terminusPoint.x : terminusPoint.x, + arrowOnY ? terminusPoint.y : originPoint.y)); + } + else if (("Broken |".equals(nextDef.getProperties().get("Type")))) + { + g2d.drawLine(originPoint.x, originPoint.y, originPoint.x, terminusPoint.y); + g2d.drawLine(originPoint.x, terminusPoint.y, terminusPoint.x, terminusPoint.y); + boolean arrowOnY = !(originPoint.y - terminusPoint.y < 60 && originPoint.y - terminusPoint.y > -60); + midPoint.x = arrowOnY ? originPoint.x : (originPoint.x + terminusPoint.x) / 2; + midPoint.y = arrowOnY ? (originPoint.y + terminusPoint.y) / 2 : terminusPoint.y; + transform.translate(midPoint.x, midPoint.y); + transform + .rotate( + calcArrowAngle( + arrowOnY ? terminusPoint.x : originPoint.x, + arrowOnY ? originPoint.y : originPoint.y, + arrowOnY ? terminusPoint.x : terminusPoint.x, + arrowOnY ? terminusPoint.y : originPoint.y)); + } + else + { + g2d.drawLine(originPoint.x, originPoint.y, terminusPoint.x, terminusPoint.y); + midPoint.x = originPoint.x + (terminusPoint.x - originPoint.x) / 2; + midPoint.y = originPoint.y + (terminusPoint.y - originPoint.y) / 2; + transform.translate(midPoint.x, midPoint.y); + transform.rotate(calcArrowAngle(originPoint.x, originPoint.y, terminusPoint.x, terminusPoint.y)); + } + + arrow = mArrowTemplate.createTransformedShape(transform); + g2d.draw(arrow); + if (text != null) + g2d.drawString(text, midPoint.x + 10, midPoint.y); + } + private static double calcArrowAngle(int originX, int originY, int terminusX, int terminusY) + { + double width = terminusX - originX; + double height = terminusY - originY; + if ((width == 0) && (height > 0)) + { + return Math.PI; + } + if ((width == 0) && (height < 0)) + { + return 0; + } + if ((width > 0) && (height == 0)) + { + return Math.PI / 2.0; + } + if ((width < 0) && (height == 0)) + { + return -1.0 * Math.PI / 2.0; + } + if ((width > 0) && (height > 0)) + { + return Math.PI / 2.0 + Math.atan(Math.abs(height) / Math.abs(width)); + } + if ((width > 0) && (height < 0)) + { + return Math.atan(Math.abs(width) / Math.abs(height)); + } + if ((width < 0) && (height < 0)) + { + return -1.0 * Math.atan(Math.abs(width) / Math.abs(height)); + } + if ((width < 0) && (height > 0)) + { + return -1.0 * (Math.PI / 2.0 + Math.atan(Math.abs(height) / Math.abs(width))); + } + return 0.0; + } +} diff --git a/src/main/java/org/cristalise/gui/lifecycle/desc/WfEdgeDefFactory.java b/src/main/java/org/cristalise/gui/lifecycle/desc/WfEdgeDefFactory.java new file mode 100644 index 0000000..e6c8fdd --- /dev/null +++ b/src/main/java/org/cristalise/gui/lifecycle/desc/WfEdgeDefFactory.java @@ -0,0 +1,30 @@ +package org.cristalise.gui.lifecycle.desc; +import org.cristalise.kernel.graph.model.DirectedEdge; +import org.cristalise.kernel.graph.model.EdgeFactory; +import org.cristalise.kernel.graph.model.GraphModelManager; +import org.cristalise.kernel.graph.model.TypeNameAndConstructionInfo; +import org.cristalise.kernel.graph.model.Vertex; +import org.cristalise.kernel.lifecycle.NextDef; +import org.cristalise.kernel.lifecycle.WfVertexDef; +public class WfEdgeDefFactory implements EdgeFactory +{ + @Override + public void create( + GraphModelManager graphModelManager, + Vertex origin, + Vertex terminus, + TypeNameAndConstructionInfo typeNameAndConstructionInfo) + { + if (validCreation(graphModelManager, origin, terminus)) + { + NextDef nextDef = new NextDef((WfVertexDef) origin, (WfVertexDef) terminus); + graphModelManager.getModel().addEdgeAndCreateId(nextDef, origin, terminus); + } + } + private static boolean validCreation(GraphModelManager graphModelManager, Vertex origin, Vertex terminus) + { + DirectedEdge[] connectingEdgesAToB = graphModelManager.getModel().getConnectingEdges(origin.getID(), terminus.getID()); + DirectedEdge[] connectingEdgesBToA = graphModelManager.getModel().getConnectingEdges(terminus.getID(), origin.getID()); + return (origin != terminus) && (connectingEdgesAToB.length == 0) && (connectingEdgesBToA.length == 0); + } +} diff --git a/src/main/java/org/cristalise/gui/lifecycle/desc/WfVertexDefFactory.java b/src/main/java/org/cristalise/gui/lifecycle/desc/WfVertexDefFactory.java new file mode 100644 index 0000000..0174096 --- /dev/null +++ b/src/main/java/org/cristalise/gui/lifecycle/desc/WfVertexDefFactory.java @@ -0,0 +1,97 @@ +package org.cristalise.gui.lifecycle.desc; +import java.util.HashMap; + +import javax.swing.JOptionPane; + +import org.cristalise.gui.ImageLoader; +import org.cristalise.gui.MainFrame; +import org.cristalise.gui.lifecycle.chooser.ActivityChooser; +import org.cristalise.gui.lifecycle.chooser.WorkflowDialogue; +import org.cristalise.kernel.graph.model.GraphModelManager; +import org.cristalise.kernel.graph.model.GraphPoint; +import org.cristalise.kernel.graph.model.TypeNameAndConstructionInfo; +import org.cristalise.kernel.graph.model.VertexFactory; +import org.cristalise.kernel.lifecycle.ActivityDef; +import org.cristalise.kernel.lifecycle.CompositeActivityDef; +import org.cristalise.kernel.utils.Language; +import org.cristalise.kernel.utils.LocalObjectLoader; +import org.cristalise.kernel.utils.Logger; + +public class WfVertexDefFactory implements VertexFactory, WorkflowDialogue +{ + protected CompositeActivityDef mCompositeActivityDef = null; + @Override + public void create(GraphModelManager graphModelManager, GraphPoint location, TypeNameAndConstructionInfo typeNameAndConstructionInfo) + { + String vertexTypeId = null; + if (mCompositeActivityDef != null && typeNameAndConstructionInfo.mInfo instanceof String) + { + vertexTypeId = (String) typeNameAndConstructionInfo.mInfo; + if (vertexTypeId.equals("Atomic") || vertexTypeId.equals("Composite")) + { + // ask for a name + HashMap mhm = new HashMap(); + mhm.put("P1", vertexTypeId); + mhm.put("P2", location); + //************************************************ + ActivityChooser a = + new ActivityChooser( + Language.translate("Please enter a Type for the new activityDef"), + Language.translate("New " + vertexTypeId + " Activity"), + ImageLoader.findImage("graph/newvertex_large.png").getImage(), + this, + mhm); + a.setVisible(true); + } + else + mCompositeActivityDef.newChild("", vertexTypeId, location); + } + } + @Override + public void loadThisWorkflow(String newName, HashMap hashMap) + { + String vertexTypeId = (String) hashMap.get("P1"); + GraphPoint location = (GraphPoint) hashMap.get("P2"); + if (newName == null || newName.equals("")) + return; + Logger.debug(5, newName); + ActivityDef act = (ActivityDef) mCompositeActivityDef.search(mCompositeActivityDef.getID() + "/" + newName); + if (act != null) + { + String unicName = newName; + while (unicName == null + || unicName == "" + || mCompositeActivityDef.search(mCompositeActivityDef.getID() + "/" + unicName) != null) + unicName = + (String) JOptionPane.showInputDialog( + null, + Language.translate("Please type a Name"), + Language.translate("New " + vertexTypeId + " Activity"), + JOptionPane.QUESTION_MESSAGE, + ImageLoader.findImage("graph/newvertex_large.png"), + null, + null); + act = (ActivityDef) mCompositeActivityDef.search(mCompositeActivityDef.getID() + "/" + newName); + mCompositeActivityDef.addExistingActivityDef(unicName, act, location); + } + else + { + try + { + act = LocalObjectLoader.getActDef(newName, 0); + } + catch (Exception ex) + { + MainFrame.exceptionDialog(ex); + return; + } + mCompositeActivityDef.newChild(newName, vertexTypeId, location); + } + } + @Override + public void setCreationContext(Object newContext) + { + if (newContext != null && newContext instanceof CompositeActivityDef) + mCompositeActivityDef = (CompositeActivityDef) newContext; + } +} diff --git a/src/main/java/org/cristalise/gui/lifecycle/desc/WfVertexDefRenderer.java b/src/main/java/org/cristalise/gui/lifecycle/desc/WfVertexDefRenderer.java new file mode 100644 index 0000000..17e2622 --- /dev/null +++ b/src/main/java/org/cristalise/gui/lifecycle/desc/WfVertexDefRenderer.java @@ -0,0 +1,31 @@ +package org.cristalise.gui.lifecycle.desc; + +import java.awt.Graphics2D; + +import org.cristalise.gui.graph.view.VertexRenderer; +import org.cristalise.kernel.graph.model.Vertex; +import org.cristalise.kernel.lifecycle.ActivitySlotDef; +import org.cristalise.kernel.lifecycle.AndSplitDef; +import org.cristalise.kernel.lifecycle.JoinDef; + + +public class WfVertexDefRenderer implements VertexRenderer +{ + protected ActivitySlotDefRenderer mActivitySlotDefRenderer = new ActivitySlotDefRenderer(); + protected SplitJoinDefRenderer mSplitJoinDefRenderer = new SplitJoinDefRenderer(); + + + @Override + public void draw( Graphics2D g2d, Vertex vertex) + { + if ( vertex instanceof ActivitySlotDef ) + { + mActivitySlotDefRenderer.draw( g2d, vertex); + } + else if ( ( vertex instanceof AndSplitDef ) || ( vertex instanceof JoinDef ) ) + { + mSplitJoinDefRenderer.draw( g2d, vertex); + } + } +} + -- cgit v1.2.3