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 --- .../gui/lifecycle/chooser/ActivityChooser.java | 195 +++++++++++++++++ .../gui/lifecycle/chooser/LDAPEntryChooser.java | 71 ++++++ .../gui/lifecycle/chooser/LDAPFileChooser.java | 120 ++++++++++ .../gui/lifecycle/chooser/WorkflowDialogue.java | 20 ++ .../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 +++ .../gui/lifecycle/instance/ActivityRenderer.java | 111 ++++++++++ .../gui/lifecycle/instance/FindActDefPanel.java | 73 +++++++ .../gui/lifecycle/instance/SplitJoinRenderer.java | 143 ++++++++++++ .../gui/lifecycle/instance/TransitionPanel.java | 215 ++++++++++++++++++ .../lifecycle/instance/WfDirectedEdgeRenderer.java | 131 +++++++++++ .../gui/lifecycle/instance/WfEdgeFactory.java | 35 +++ .../gui/lifecycle/instance/WfGraphPanel.java | 60 +++++ .../gui/lifecycle/instance/WfVertexFactory.java | 93 ++++++++ .../gui/lifecycle/instance/WfVertexRenderer.java | 24 ++ 22 files changed, 2325 insertions(+) create mode 100644 src/main/java/org/cristalise/gui/lifecycle/chooser/ActivityChooser.java create mode 100644 src/main/java/org/cristalise/gui/lifecycle/chooser/LDAPEntryChooser.java create mode 100644 src/main/java/org/cristalise/gui/lifecycle/chooser/LDAPFileChooser.java create mode 100644 src/main/java/org/cristalise/gui/lifecycle/chooser/WorkflowDialogue.java 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 create mode 100644 src/main/java/org/cristalise/gui/lifecycle/instance/ActivityRenderer.java create mode 100644 src/main/java/org/cristalise/gui/lifecycle/instance/FindActDefPanel.java create mode 100644 src/main/java/org/cristalise/gui/lifecycle/instance/SplitJoinRenderer.java create mode 100644 src/main/java/org/cristalise/gui/lifecycle/instance/TransitionPanel.java create mode 100644 src/main/java/org/cristalise/gui/lifecycle/instance/WfDirectedEdgeRenderer.java create mode 100644 src/main/java/org/cristalise/gui/lifecycle/instance/WfEdgeFactory.java create mode 100644 src/main/java/org/cristalise/gui/lifecycle/instance/WfGraphPanel.java create mode 100644 src/main/java/org/cristalise/gui/lifecycle/instance/WfVertexFactory.java create mode 100644 src/main/java/org/cristalise/gui/lifecycle/instance/WfVertexRenderer.java (limited to 'src/main/java/org/cristalise/gui/lifecycle') diff --git a/src/main/java/org/cristalise/gui/lifecycle/chooser/ActivityChooser.java b/src/main/java/org/cristalise/gui/lifecycle/chooser/ActivityChooser.java new file mode 100644 index 0000000..d63a2c5 --- /dev/null +++ b/src/main/java/org/cristalise/gui/lifecycle/chooser/ActivityChooser.java @@ -0,0 +1,195 @@ +/* + * Created on 1 sept. 2003 + * + * To change the template for this generated file go to Window>Preferences>Java>Code Generation>Code and Comments + */ +package org.cristalise.gui.lifecycle.chooser; + +import java.awt.Container; +import java.awt.Cursor; +import java.awt.Dimension; +import java.awt.Image; +import java.awt.Toolkit; +import java.awt.event.ActionEvent; +import java.awt.event.ActionListener; +import java.util.HashMap; + +import javax.swing.BorderFactory; +import javax.swing.Box; +import javax.swing.BoxLayout; +import javax.swing.JButton; +import javax.swing.JFrame; +import javax.swing.JLabel; +import javax.swing.JPanel; + +import org.cristalise.gui.ImageLoader; +import org.cristalise.kernel.utils.Language; +import org.cristalise.kernel.utils.Logger; + + +/** + * @author Developpement + * + * To change the template for this generated type comment go to + * Window>Preferences>Java>Code Generation>Code and Comments + */ +public class ActivityChooser extends JFrame +{ + private LDAPFileChooser mLDAPFileChooserActivity = null; + + private JButton mButtonOK = null; + + private JButton mButtonCancel = null; + + private JPanel mJPanelVertical = null; + + private JPanel mJPanelHorizontal = null; + + private String mMessage = "Choose or modify"; + + private WorkflowDialogue mParent = null; + + private JLabel label = null; + + HashMap mhashmap = null; + + public ActivityChooser(String message, String title, Image img, WorkflowDialogue parent, HashMap hashmap) + { + super(title); + mMessage = message; + img = ImageLoader.findImage("graph/newvertex_large.png").getImage(); + setIconImage(img); + mParent = parent; + mhashmap = hashmap; + initialize(); + } + + private JButton getJButtonOK() + { + if (mButtonOK == null) + mButtonOK = new JButton(Language.translate("OK")); + return mButtonOK; + } + + private JButton getJButtonCancel() + { + if (mButtonCancel == null) + mButtonCancel = new JButton(Language.translate("Cancel")); + return mButtonCancel; + } + + private LDAPFileChooser getLDAPFileChooserActivity() + { + if (mLDAPFileChooserActivity == null) + { + try + { + mLDAPFileChooserActivity = new LDAPFileChooser(LDAPFileChooser.ACTIVITY_CHOOSER); + mLDAPFileChooserActivity.setName("LDAPFileChooserRouting"); + mLDAPFileChooserActivity.setEditable(false); + //mLDAPFileChooserActivity.setBounds(125, 13, 400, 19); + } catch (Exception mExc) + { + Logger.error(mExc); + } + } + return mLDAPFileChooserActivity; + } + + private void initialize() + { + getJButtonOK().addActionListener(new ActionListener() + { + @Override + public void actionPerformed(ActionEvent e) + { + Logger.debug(5, "mLDAPFileChooserActivity.getEntryName()" + mLDAPFileChooserActivity.getEntryName()); + setCursor(new Cursor(Cursor.WAIT_CURSOR)); + mParent.loadThisWorkflow(mLDAPFileChooserActivity.getEntryName(), mhashmap); + setCursor(new Cursor(Cursor.DEFAULT_CURSOR)); + close(); + } + }); + getJButtonCancel().addActionListener(new ActionListener() + { + @Override + public void actionPerformed(ActionEvent e) + { + close(); + } + }); + //getContentPane().add(getJPanelVertical()); + Container contentPane = getContentPane(); + contentPane.setLayout(new BoxLayout(contentPane, BoxLayout.Y_AXIS)); + contentPane.add(getJPanelVertical()); + contentPane.add(getJPanelHorizontal()); + contentPane.add(Box.createGlue()); + Dimension d = Toolkit.getDefaultToolkit().getScreenSize(); + setLocation((d.width - getWidth()) / 2, (d.height - getHeight()) / 2); + setResizable(true); + pack(); + setSize(new Dimension(getWidth(), getJButtonCancel().getHeight() + getLDAPFileChooserActivity().getHeight() + label.getHeight() + 100)); + setVisible(true); + setVisible(true); + } + + private void close() + { + mParent = null; + this.setEnabled(false); + this.setVisible(false); + } + + private JPanel getJPanelVertical() + { + if (mJPanelVertical == null) + { + try + { + Logger.debug(8, "Panel button"); + mJPanelVertical = new JPanel(); + mJPanelVertical.setName("JPanelV"); + mJPanelVertical.setLayout(new BoxLayout(mJPanelVertical, BoxLayout.Y_AXIS)); + label = new JLabel(mMessage); + JPanel labelP = new JPanel(); + labelP.setLayout(new BoxLayout(labelP, BoxLayout.X_AXIS)); + labelP.add(label); + labelP.add(Box.createGlue()); + mJPanelVertical.add(labelP); + mJPanelVertical.add(Box.createRigidArea(new Dimension(0, 5))); + mJPanelVertical.add(getLDAPFileChooserActivity(), getLDAPFileChooserActivity().getName()); + //mJPanelVertical.add(Box.createRigidArea(new Dimension(0, + // 10))); + mJPanelVertical.add(Box.createGlue()); + mJPanelVertical.setBorder(BorderFactory.createEmptyBorder(10, 10, 10, 10)); + mJPanelVertical.setVisible(true); + } catch (java.lang.Throwable mExc) + { + //handleException(mExc); + } + } + return mJPanelVertical; + } + + private JPanel getJPanelHorizontal() + { + if (mJPanelHorizontal == null) + { + try + { + Logger.debug(8, "Panel button"); + mJPanelHorizontal = new JPanel(); + mJPanelHorizontal.setName("JPanelH"); + mJPanelHorizontal.setLayout(new BoxLayout(mJPanelHorizontal, BoxLayout.X_AXIS)); + mJPanelHorizontal.add(getJButtonOK(), getJButtonOK().getName()); + mJPanelHorizontal.add(Box.createRigidArea(new Dimension(10, 0))); + mJPanelHorizontal.add(getJButtonCancel(), getJButtonCancel().getName()); + mJPanelHorizontal.setVisible(true); + } catch (java.lang.Throwable mExc) + { + //handleException(mExc); + } + } + return mJPanelHorizontal; + } +} \ No newline at end of file diff --git a/src/main/java/org/cristalise/gui/lifecycle/chooser/LDAPEntryChooser.java b/src/main/java/org/cristalise/gui/lifecycle/chooser/LDAPEntryChooser.java new file mode 100644 index 0000000..90c759f --- /dev/null +++ b/src/main/java/org/cristalise/gui/lifecycle/chooser/LDAPEntryChooser.java @@ -0,0 +1,71 @@ +package org.cristalise.gui.lifecycle.chooser; +/** + * @version $Revision: 1.2 $ $Date: 2005/12/01 14:23:15 $ + * @author $Author: abranson $ + */ + +import java.awt.Dimension; +import java.util.ArrayList; +import java.util.Collections; +import java.util.Iterator; + +import javax.swing.JComboBox; + +import org.cristalise.gui.MainFrame; +import org.cristalise.kernel.lookup.DomainPath; +import org.cristalise.kernel.process.Gateway; + + +public class LDAPEntryChooser extends JComboBox +{ + + DomainPath mDomainPath = null; + ArrayList allItems = new ArrayList(); + + public LDAPEntryChooser(DomainPath domPath, boolean editable) + { + super(); + setEditable(editable); + mDomainPath = domPath; + initialise(); + } + + private void initialise() + { + try + { + Iterator children = Gateway.getLookup().search(mDomainPath, "*"); + while (children.hasNext()) + { + DomainPath domPath = (DomainPath)children.next(); + allItems.add(domPath.getName()); + } + } + catch (Exception ex) + { + MainFrame.exceptionDialog(ex); + } + + Collections.sort(allItems); + addItem(""); + for (String element : allItems) { + addItem(element); + } + + } + + public void reload() + { + removeAllItems(); + initialise(); + } + + @Override + public synchronized Dimension getSize() + { + if (Gateway.getProperties().getInt("ResizeCombo") > 0) + return new Dimension(super.getSize().width<400?400:super.getSize().width,super.getSize().height); + return super.getSize(); + } + +} diff --git a/src/main/java/org/cristalise/gui/lifecycle/chooser/LDAPFileChooser.java b/src/main/java/org/cristalise/gui/lifecycle/chooser/LDAPFileChooser.java new file mode 100644 index 0000000..ed594f4 --- /dev/null +++ b/src/main/java/org/cristalise/gui/lifecycle/chooser/LDAPFileChooser.java @@ -0,0 +1,120 @@ +package org.cristalise.gui.lifecycle.chooser; +import java.awt.Dimension; +import java.awt.event.ItemListener; + +import javax.swing.BoxLayout; +import javax.swing.JPanel; + +import org.cristalise.kernel.lookup.DomainPath; +import org.cristalise.kernel.persistency.ClusterStorage; +import org.cristalise.kernel.utils.Logger; + + +//import fr.agilium.gui.tabs.wfPropertiesViewer.JPanelTabbedProperties; +/** + * @version $Revision: 1.2 $ $Date: 2005/06/27 15:16:12 $ + * @author $Author: abranson $ + */ + +public class LDAPFileChooser extends JPanel +{ + public static String SCRIPT_CHOOSER = "Script"; + public static String SCHEMA_CHOOSER = "Schema"; + public static String ACTIVITY_CHOOSER = "Activity"; + private String chooserMode = null; + public LDAPEntryChooser mLec; + private boolean mEditable = false; + DomainPath domainPath; + String itemQuery = null; + boolean showversion = true; + + public LDAPFileChooser(String choose) + { + super(); + chooserMode = choose; + initialise(); + } + + private void initialise() + { + if (chooserMode.equals(SCHEMA_CHOOSER)) + { + itemQuery = ClusterStorage.VIEWPOINT + "/Schema/all"; + domainPath = new DomainPath("/desc/OutcomeDesc/"); + } + else if (chooserMode.equals(SCRIPT_CHOOSER)) + { + itemQuery = ClusterStorage.VIEWPOINT + "/Script/all"; + domainPath = new DomainPath("/desc/Script/"); + } + else if (chooserMode.equals(ACTIVITY_CHOOSER)) + { + domainPath = new DomainPath("/desc/ActivityDesc/"); + showversion = false; + } + else + return; + mLec = new LDAPEntryChooser(domainPath, mEditable); + + mLec.setPreferredSize(new Dimension(220, 19)); + mLec.setMaximumSize(new Dimension(3000, 22)); + mLec.setMinimumSize(new Dimension(50, 19)); + //mLec.getRenderer().getListCellRendererComponent(); + + BoxLayout blyt = new BoxLayout(this, BoxLayout.X_AXIS); + setLayout(blyt); + add(mLec); + mLec.setVisible(true); + this.validate(); + this.setVisible(true); + + } + + public String getEntryName() + { + return (String) mLec.getSelectedItem(); + } + + public void addItemListener(ItemListener il) + { + mLec.addItemListener(il); + } + public void setSelectedItem(String name, String version) + { + Logger.debug(5,"setSelectedItem " + name + " " + version); + if (name == null||name.equals("-1")) name=""; + mLec.setSelectedItem(name); + } + + public void reload() + { + mLec.reload(); + } + + public void removeAllItems() + { + mLec.removeAllItems(); + } + + /** + * @param b + */ + public void setEditable(boolean b) + { + mEditable = b; + mLec.setEditable(b); + } + + @Override + public void updateUI() + { + if (mLec!=null) mLec.updateUI(); + super.updateUI(); + } + + @Override + public void setEnabled(boolean enabled) + { + mLec.setEnabled(enabled); + } +} diff --git a/src/main/java/org/cristalise/gui/lifecycle/chooser/WorkflowDialogue.java b/src/main/java/org/cristalise/gui/lifecycle/chooser/WorkflowDialogue.java new file mode 100644 index 0000000..7ee6b5f --- /dev/null +++ b/src/main/java/org/cristalise/gui/lifecycle/chooser/WorkflowDialogue.java @@ -0,0 +1,20 @@ +/* + * Created on 2 sept. 2003 + * + * To change the template for this generated file go to + * Window>Preferences>Java>Code Generation>Code and Comments + */ +package org.cristalise.gui.lifecycle.chooser; + +import java.util.HashMap; + +/** + * @author Developpement + * + * To change the template for this generated type comment go to + * Window>Preferences>Java>Code Generation>Code and Comments + */ +public interface WorkflowDialogue +{ + public void loadThisWorkflow(String name, HashMap mhashmap); +} 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); + } + } +} + diff --git a/src/main/java/org/cristalise/gui/lifecycle/instance/ActivityRenderer.java b/src/main/java/org/cristalise/gui/lifecycle/instance/ActivityRenderer.java new file mode 100644 index 0000000..f4d44b9 --- /dev/null +++ b/src/main/java/org/cristalise/gui/lifecycle/instance/ActivityRenderer.java @@ -0,0 +1,111 @@ +package org.cristalise.gui.lifecycle.instance; +import java.awt.Color; +import java.awt.FontMetrics; +import java.awt.Graphics2D; +import java.awt.Paint; +import java.awt.Polygon; + +import org.cristalise.gui.graph.view.VertexRenderer; +import org.cristalise.kernel.common.GTimeStamp; +import org.cristalise.kernel.common.InvalidDataException; +import org.cristalise.kernel.graph.model.GraphPoint; +import org.cristalise.kernel.graph.model.Vertex; +import org.cristalise.kernel.lifecycle.instance.Activity; +import org.cristalise.kernel.utils.DateUtility; +import org.cristalise.kernel.utils.Language; + +public class ActivityRenderer implements VertexRenderer +{ + private Paint mActivePaint = new Color(100, 255, 100); + private Paint mActiveCompPaint = new Color(100, 255, 255); + private Paint mInactivePaint = new Color(255, 255, 255); + private Paint mInactiveCompPaint = new Color(200, 200, 255); + private Paint mErrorPaint = new Color(255, 50, 0); + private Paint mTextPaint = Color.black; + @Override + public void draw(Graphics2D g2d, Vertex vertex) + { + Activity activity = (Activity) vertex; + boolean active = activity.getActive(); + boolean hasError = !activity.verify(); + boolean isComposite = activity.getIsComposite(); + GraphPoint centrePoint = activity.getCentrePoint(); + //String description = activity.getDescription(); + String[] linesOfText = new String[3]; + linesOfText[0] = "(" + activity.getType() + ")"; + linesOfText[1] = activity.getName(); + if (hasError) + linesOfText[2] = Language.translate(activity.getErrors()); + else + { + boolean showTime = activity.getActive() && ((Boolean) activity.getProperties().get("Show time")).booleanValue(); + String stateName = "Invalid State"; + try { + stateName = activity.getStateName(); + } catch (InvalidDataException ex) { } + + linesOfText[2] = + Language.translate(stateName) + (showTime ? " " + getWaitTime(activity.getStateDate()) : ""); + } + + 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; + GraphPoint[] outline = vertex.getOutlinePoints(); + Paint actColour; + if (hasError) + actColour = mErrorPaint; + else if (active) + if (isComposite) + actColour = mActiveCompPaint; + else + actColour = mActivePaint; + else if (isComposite) + actColour = mInactiveCompPaint; + else + actColour = mInactivePaint; + g2d.setPaint(actColour); + //g2d.fill3DRect( centrePoint.x - mSize.width / 2, centrePoint.y - mSize.height / 2, mSize.width, mSize.height, true ); + g2d.fill(graphPointsToPolygon(outline)); + g2d.setPaint(mTextPaint); + for (i = 0; i < linesOfText.length; i++) + { + lineWidth = metrics.stringWidth(linesOfText[i]); + x = centrePoint.x - lineWidth / 2; + y = linesStartY + i * lineHeight; + g2d.drawString(linesOfText[i], x, y); + } + } + private static Polygon graphPointsToPolygon(GraphPoint[] points) + { + Polygon polygon = new Polygon(); + int i = 0; + for (i = 0; i < points.length; i++) + { + polygon.addPoint(points[i].x, points[i].y); + } + return polygon; + } + private static String getWaitTime(GTimeStamp date) + { + GTimeStamp now = new GTimeStamp(); + DateUtility.setToNow(now); + long diff = DateUtility.diff(now, date); + long secondes = diff % 60; + long minutes = (diff / 60) % 60; + long hours = (diff / 3600) % 24; + long days = (diff / 3600 / 24); + if (days > 0) + return days + " " + Language.translate("d") + " " + hours + " " + Language.translate("h"); + if (hours > 0) + return hours + " " + Language.translate("h") + " " + minutes + " " + Language.translate("min"); + if (minutes > 0) + return minutes + " " + Language.translate("min"); + return secondes + " " + Language.translate("sec"); + } +} diff --git a/src/main/java/org/cristalise/gui/lifecycle/instance/FindActDefPanel.java b/src/main/java/org/cristalise/gui/lifecycle/instance/FindActDefPanel.java new file mode 100644 index 0000000..4c3acbc --- /dev/null +++ b/src/main/java/org/cristalise/gui/lifecycle/instance/FindActDefPanel.java @@ -0,0 +1,73 @@ +package org.cristalise.gui.lifecycle.instance; + +import java.awt.event.ActionEvent; +import java.awt.event.ActionListener; +import java.util.Iterator; + +import javax.swing.JButton; + +import org.cristalise.gui.MainFrame; +import org.cristalise.gui.graph.view.SelectedVertexPanel; +import org.cristalise.kernel.graph.model.Vertex; +import org.cristalise.kernel.lifecycle.ActivitySlotDef; +import org.cristalise.kernel.lookup.DomainPath; +import org.cristalise.kernel.lookup.Path; +import org.cristalise.kernel.process.Gateway; + + +/************************************************************************** + * + * $Revision: 1.3 $ + * $Date: 2005/12/01 14:23:15 $ + * + * Copyright (C) 2003 CERN - European Organization for Nuclear Research + * All rights reserved. + **************************************************************************/ + +public class FindActDefPanel extends SelectedVertexPanel { + + JButton findButton; + ActivitySlotDef currentAct; + + public FindActDefPanel() { + super(); + findButton = new JButton("Open Definition"); + findButton.setEnabled(false); + add(findButton); + findButton.addActionListener(new ActionListener() + { + @Override + public void actionPerformed(ActionEvent e) + { + Iterator acts = Gateway.getLookup().search(new DomainPath("/desc/ActivityDesc/"), currentAct.getActivityDef()); + if (acts.hasNext()) MainFrame.treeBrowser.push((DomainPath)acts.next()); + } + }); + } + + /** + * + */ + + @Override + public void select(Vertex vert) { + if (vert instanceof ActivitySlotDef) { + findButton.setEnabled(true); + currentAct = (ActivitySlotDef)vert; + } + else + clear(); + + } + + /** + * + */ + + @Override + public void clear() { + findButton.setEnabled(false); + currentAct = null; + } + +} diff --git a/src/main/java/org/cristalise/gui/lifecycle/instance/SplitJoinRenderer.java b/src/main/java/org/cristalise/gui/lifecycle/instance/SplitJoinRenderer.java new file mode 100644 index 0000000..8667fed --- /dev/null +++ b/src/main/java/org/cristalise/gui/lifecycle/instance/SplitJoinRenderer.java @@ -0,0 +1,143 @@ +package org.cristalise.gui.lifecycle.instance; + +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.instance.AndSplit; +import org.cristalise.kernel.lifecycle.instance.Join; +import org.cristalise.kernel.lifecycle.instance.Loop; +import org.cristalise.kernel.lifecycle.instance.OrSplit; +import org.cristalise.kernel.lifecycle.instance.WfVertex; +import org.cristalise.kernel.lifecycle.instance.XOrSplit; +import org.cristalise.kernel.utils.Language; + + +public class SplitJoinRenderer implements VertexRenderer +{ + private Paint mTextPaint = Color.black; + private Paint mBoxPaint = new Color( 204, 204, 204 ); + private Paint mErrorPaint = new Color( 255, 0, 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 mLoopText = "Loop"; + private int mLoopTextXOffset = 0; + private String mXOrText = "XOr"; + private int mXOrTextXOffset = 0; + private String mJoinText = "Join"; + private int mJoinTextXOffset = 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(); + + + if ( mTextOffsetsNotInitialised ) + { + initialiseTextOffsets( g2d ); + mTextOffsetsNotInitialised = false; + } + if ( vertex instanceof AndSplit ) + { + text = Language.translate(mAndText); + textXOffset = mAndTextXOffset; + } + else if ( vertex instanceof OrSplit ) + { + text = Language.translate(mOrText); + textXOffset = mOrTextXOffset; + } + else if ( vertex instanceof Loop ) + { + text = Language.translate(mLoopText); + textXOffset = mLoopTextXOffset; + } + else if ( vertex instanceof XOrSplit ) + { + text = Language.translate(mXOrText); + textXOffset = mXOrTextXOffset; + } + else if ( vertex instanceof Join ) + { + text = Language.translate(mJoinText); + textXOffset = mJoinTextXOffset; + } + else if ( vertex instanceof Join) + { + String type= (String)((Join)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; + } + + boolean hasErrors = ((WfVertex)vertex).verify(); + g2d.setPaint( hasErrors ? mBoxPaint : mErrorPaint ); + 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 (!hasErrors) { + g2d.setPaint( mErrorPaint ); + String errors = Language.translate(((WfVertex)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(mLoopText) ) / 2; + } +} + diff --git a/src/main/java/org/cristalise/gui/lifecycle/instance/TransitionPanel.java b/src/main/java/org/cristalise/gui/lifecycle/instance/TransitionPanel.java new file mode 100644 index 0000000..d58422d --- /dev/null +++ b/src/main/java/org/cristalise/gui/lifecycle/instance/TransitionPanel.java @@ -0,0 +1,215 @@ +package org.cristalise.gui.lifecycle.instance; + +import java.awt.GridBagConstraints; +import java.awt.GridBagLayout; +import java.awt.event.ActionEvent; +import java.awt.event.ActionListener; +import java.util.Map; + +import javax.swing.Box; +import javax.swing.JButton; +import javax.swing.JCheckBox; +import javax.swing.JComboBox; +import javax.swing.JLabel; +import javax.swing.JOptionPane; + +import org.cristalise.gui.MainFrame; +import org.cristalise.gui.graph.view.SelectedVertexPanel; +import org.cristalise.gui.tabs.ItemTabPane; +import org.cristalise.gui.tabs.execution.Executor; +import org.cristalise.kernel.common.InvalidDataException; +import org.cristalise.kernel.entity.agent.Job; +import org.cristalise.kernel.entity.proxy.ItemProxy; +import org.cristalise.kernel.graph.model.Vertex; +import org.cristalise.kernel.lifecycle.instance.Activity; +import org.cristalise.kernel.lifecycle.instance.stateMachine.State; +import org.cristalise.kernel.lifecycle.instance.stateMachine.StateMachine; +import org.cristalise.kernel.lifecycle.instance.stateMachine.Transition; +import org.cristalise.kernel.utils.Logger; + + +/************************************************************************** + * + * $Revision: 1.8 $ + * $Date: 2005/09/07 13:46:31 $ + * + * Copyright (C) 2003 CERN - European Organization for Nuclear Research + * All rights reserved. + **************************************************************************/ + +public class TransitionPanel extends SelectedVertexPanel implements ActionListener { + protected Activity mCurrentAct; + protected GridBagLayout gridbag; + protected GridBagConstraints c; + protected Box transBox; + protected JComboBox executors; + protected JComboBox states = new JComboBox(); + protected JCheckBox active = new JCheckBox(); + protected JLabel status = new JLabel(); + protected ItemProxy mItem; + + public TransitionPanel() { + super(); + gridbag = new GridBagLayout(); + setLayout(gridbag); + c = new GridBagConstraints(); + c.gridx=0; c.gridy=0; + c.weightx=1; c.weighty=0; + c.fill=GridBagConstraints.HORIZONTAL; + + JLabel title = new JLabel("Available Transitions"); + title.setFont(ItemTabPane.titleFont); + gridbag.setConstraints(title, c); + add(title); + + c.gridy++; + gridbag.setConstraints(status, c); + add(status); + c.gridy++; + + transBox = Box.createHorizontalBox(); + gridbag.setConstraints(transBox, c); + add(transBox); + + c.weightx=0; c.gridx++; + executors = MainFrame.getExecutionPlugins(); + if (executors.getItemCount() > 1) { + gridbag.setConstraints(executors, c); + add(executors); + } + + + + if (MainFrame.isAdmin) { + c.gridx=0; c.gridy++; + title = new JLabel("State Hacking"); + title.setFont(ItemTabPane.titleFont); + gridbag.setConstraints(title, c); + add(title); + Box hackBox = Box.createHorizontalBox(); + hackBox.add(states); + hackBox.add(Box.createHorizontalGlue()); + hackBox.add(new JLabel("Active:")); + hackBox.add(active); + c.gridy++; + gridbag.setConstraints(hackBox, c); + add(hackBox); + states.addActionListener(this); + active.addActionListener(this); + } + + clear(); + + } + /** + * + */ + @Override + public void select(Vertex vert) { + clear(); + if (!(vert instanceof Activity)) return; + mCurrentAct = (Activity)vert; + StateMachine sm; + try { + sm = mCurrentAct.getStateMachine(); + } catch (InvalidDataException e) { + status.setText("Invalid state machine."); + Logger.error(e); + return; + } + states.removeAllItems(); + int currentState; + try { + currentState = mCurrentAct.getState(); + } catch (InvalidDataException e) { + status.setText("Could not find activity state"); + Logger.error(e); + return; + } + for (State thisState : sm.getStates()) { + states.addItem(thisState); + if (currentState == thisState.getId()) + states.setSelectedItem(thisState); + } + states.setEnabled(true); + active.setSelected(mCurrentAct.active); + active.setEnabled(true); + Logger.msg(1, "Retrieving possible transitions for activity "+mCurrentAct.getName()); + Map transitions; + try { + transitions = mCurrentAct.getStateMachine().getPossibleTransitions(mCurrentAct, MainFrame.userAgent.getPath()); + } catch (Exception e) { + status.setText("Error loading possible transitions of activity. See log."); + Logger.error(e); + return; + } + + if (transitions.size() == 0) { + status.setText("None"); + return; + } + + for (Transition trans:transitions.keySet()) { + boolean hasOutcome = trans.hasOutcome(mCurrentAct.getProperties()); + if (!hasOutcome || (hasOutcome && !trans.getOutcome().isRequired())) { + JButton thisTrans = new JButton(trans.getName()); + thisTrans.setActionCommand("Trans:"+trans.getId()); + thisTrans.addActionListener(this); + transBox.add(thisTrans); + transBox.add(Box.createHorizontalGlue()); + } + status.setText(transitions.size()+" transitions possible."); + } + revalidate(); + } + + @Override + public void actionPerformed(ActionEvent e) { + if (e.getSource() == active && mCurrentAct != null) { + mCurrentAct.active = active.isSelected(); + return; + } + if (e.getSource() == states && mCurrentAct != null) { + mCurrentAct.setState(states.getSelectedIndex()); + return; + } + if (!e.getActionCommand().startsWith("Trans:")) return; + int transition = Integer.parseInt(e.getActionCommand().substring(6)); + Logger.msg("Requesting transition "+transition); + try { + StateMachine actSM = mCurrentAct.getStateMachine(); + Job thisJob = new Job(mCurrentAct, + mItem.getPath(), + actSM.getTransition(transition), + MainFrame.userAgent.getPath(), + "Admin"); + Executor selectedExecutor = (Executor)executors.getSelectedItem(); + selectedExecutor.execute(thisJob, status); + } catch (Exception ex) { + String className = ex.getClass().getName(); + className = className.substring(className.lastIndexOf('.')+1); + Logger.error(ex); + JOptionPane.showMessageDialog(null, ex.getMessage(), className, JOptionPane.ERROR_MESSAGE); + } + + } + + @Override + public void clear() { + mCurrentAct = null; + transBox.removeAll(); + status.setText("No activity selected"); + states.setEnabled(false); + active.setSelected(false); + active.setEnabled(false); + revalidate(); + } + + + /** + * @param item The mItem to set. + */ + public void setItem(ItemProxy item) { + mItem = item; + } +} diff --git a/src/main/java/org/cristalise/gui/lifecycle/instance/WfDirectedEdgeRenderer.java b/src/main/java/org/cristalise/gui/lifecycle/instance/WfDirectedEdgeRenderer.java new file mode 100644 index 0000000..1dce7e7 --- /dev/null +++ b/src/main/java/org/cristalise/gui/lifecycle/instance/WfDirectedEdgeRenderer.java @@ -0,0 +1,131 @@ +package org.cristalise.gui.lifecycle.instance; +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.instance.Next; + +public class WfDirectedEdgeRenderer implements DirectedEdgeRenderer +{ + private GeneralPath mArrowTemplate = new GeneralPath(); + public WfDirectedEdgeRenderer() + { + 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; + Next next = (Next) directedEdge; + String text = (String) next.getProperties().get("Alias"); + g2d.setPaint(Color.black); + if (("Broken +".equals(next.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(next.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(next.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/instance/WfEdgeFactory.java b/src/main/java/org/cristalise/gui/lifecycle/instance/WfEdgeFactory.java new file mode 100644 index 0000000..d6596b6 --- /dev/null +++ b/src/main/java/org/cristalise/gui/lifecycle/instance/WfEdgeFactory.java @@ -0,0 +1,35 @@ +package org.cristalise.gui.lifecycle.instance; + +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.instance.WfVertex; + +public class WfEdgeFactory implements EdgeFactory +{ + @Override + public void create + ( + GraphModelManager graphModelManager, + Vertex origin, + Vertex terminus, + TypeNameAndConstructionInfo typeNameAndConstructionInfo + ) + { + if ( validCreation( graphModelManager, origin, terminus ) ) + ((WfVertex)origin).addNext((WfVertex)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/instance/WfGraphPanel.java b/src/main/java/org/cristalise/gui/lifecycle/instance/WfGraphPanel.java new file mode 100644 index 0000000..1d8a3e3 --- /dev/null +++ b/src/main/java/org/cristalise/gui/lifecycle/instance/WfGraphPanel.java @@ -0,0 +1,60 @@ +/*Created on 21 nov. 2003 */ +package org.cristalise.gui.lifecycle.instance; + +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.instance.Next; + + +/** @author XSeb74*/ +public class WfGraphPanel extends GraphPanel +{ + public WfGraphPanel(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(((Next)edge).getProperties().get("Type")) || ((Next)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(((Next)edge).getProperties().get("Type")))) + { + midPoint.x = (originPoint.x + terminusPoint.x) / 2; + midPoint.y = (originPoint.y + terminusPoint.y) / 2; + } + else if (("Broken -".equals(((Next)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(((Next)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/instance/WfVertexFactory.java b/src/main/java/org/cristalise/gui/lifecycle/instance/WfVertexFactory.java new file mode 100644 index 0000000..d80d18c --- /dev/null +++ b/src/main/java/org/cristalise/gui/lifecycle/instance/WfVertexFactory.java @@ -0,0 +1,93 @@ +package org.cristalise.gui.lifecycle.instance; +import java.io.Serializable; +import java.util.HashMap; + +import javax.swing.JOptionPane; + +import org.cristalise.gui.ImageLoader; +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.instance.Activity; +import org.cristalise.kernel.lifecycle.instance.CompositeActivity; +import org.cristalise.kernel.utils.Language; +import org.cristalise.kernel.utils.LocalObjectLoader; + +public class WfVertexFactory implements VertexFactory, WorkflowDialogue +{ + protected CompositeActivity mRootAct = null; + @Override + public void create(GraphModelManager graphModelManager, GraphPoint location, TypeNameAndConstructionInfo typeNameAndConstructionInfo) + { + String vertexTypeId = null; + if (mRootAct != null && typeNameAndConstructionInfo.mInfo instanceof String) + { + vertexTypeId = (String) typeNameAndConstructionInfo.mInfo; + if (vertexTypeId.equals("Atomic") || vertexTypeId.equals("Composite")) + { + 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 activity"), + Language.translate("New " + vertexTypeId + " Activity"), + ImageLoader.findImage("graph/newvertex_large.png").getImage(), + this, + mhm); + a.setVisible(true); + } + else + mRootAct.newChild(vertexTypeId, location); + } + } + @Override + public void setCreationContext(Object newContext) + { + if (newContext != null && newContext instanceof CompositeActivity) + mRootAct = (CompositeActivity) newContext; + } + @Override + public void loadThisWorkflow(String newName, HashMap hashMap) + { + String vertexTypeId = (String) hashMap.get("P1"); + GraphPoint location = (GraphPoint) hashMap.get("P2"); + if (newName == null) + return; + + + String unicName = newName; + while (mRootAct.search(mRootAct.getPath() + "/" + unicName) != null) + { + unicName = + (String) JOptionPane.showInputDialog( + null, + Language.translate("Activity name not unique. Please give another."), + Language.translate("New " + vertexTypeId + " Activity"), + JOptionPane.QUESTION_MESSAGE, + ImageLoader.findImage("graph/newvertex_large.png"), + null, + null); + if (newName.equals("")) + return; + } + Activity act = null; + try + { + ActivityDef actD = LocalObjectLoader.getActDef(newName, 0); + act = (Activity)actD.instantiate(unicName); + } + catch (Exception e) + { + } + if (act == null) + mRootAct.newChild(unicName, vertexTypeId, location); + else + mRootAct.newExistingChild(act, unicName, location); + } +} diff --git a/src/main/java/org/cristalise/gui/lifecycle/instance/WfVertexRenderer.java b/src/main/java/org/cristalise/gui/lifecycle/instance/WfVertexRenderer.java new file mode 100644 index 0000000..61944fc --- /dev/null +++ b/src/main/java/org/cristalise/gui/lifecycle/instance/WfVertexRenderer.java @@ -0,0 +1,24 @@ +package org.cristalise.gui.lifecycle.instance; + +import java.awt.Graphics2D; + +import org.cristalise.gui.graph.view.VertexRenderer; +import org.cristalise.kernel.graph.model.Vertex; +import org.cristalise.kernel.lifecycle.instance.Activity; +import org.cristalise.kernel.lifecycle.instance.Join; +import org.cristalise.kernel.lifecycle.instance.Split; + + +public class WfVertexRenderer implements VertexRenderer +{ + protected ActivityRenderer mActivityRenderer = new ActivityRenderer(); + protected SplitJoinRenderer mSplitJoinRenderer = new SplitJoinRenderer(); + + @Override + public void draw( Graphics2D g2d, Vertex vertex) + { + if ( vertex instanceof Activity ) { mActivityRenderer.draw( g2d, vertex); } + else if ( ( vertex instanceof Split ) || ( vertex instanceof Join ) ) { mSplitJoinRenderer.draw( g2d, vertex ); } + } +} + -- cgit v1.2.3