diff options
Diffstat (limited to 'src/main/java/org/cristalise/gui/lifecycle')
22 files changed, 2325 insertions, 0 deletions
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<String, Object> mhashmap = null;
+
+ public ActivityChooser(String message, String title, Image img, WorkflowDialogue parent, HashMap<String, Object> 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<String> allItems = new ArrayList<String>();
+
+ 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<String, Object> 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; i<compActDef.getChildren().length; i++) { // export slot defined scripts and schemas
+ GraphableVertex vert = compActDef.getChildren()[i];
+ exportScript((String)vert.getProperties().get("ScriptName"), actDef.getProperties().get("ScriptVersion"), imports, new File(dir, "SC"));
+ exportScript((String)vert.getProperties().get("RoutingScriptName"), actDef.getProperties().get("RoutingScriptVersion"), imports, new File(dir, "SC"));
+ exportSchema((String)vert.getProperties().get("SchemaType"), actDef.getProperties().get("SchemaVersion"), imports, new File(dir, "OD"));
+ }
+ GraphableVertex[] childDefs = compActDef.getLayoutableChildren();
+ for (GraphableVertex childDef : childDefs) {
+ if (childDef instanceof ActivitySlotDef) {
+ if ("last".equals(childDef.getProperties().get("Version"))) {
+ resolveRealVersion((ActivitySlotDef)childDef);
+ }
+ exportAct(dir, imports, ((ActivitySlotDef)childDef).getTheActivityDef());
+ }
+ }
+ // export marshalled compAct
+ FileStringUtility.string2File(new File(new File(dir, "CA"), compActDef.getActName()+".xml"), Gateway.getMarshaller().marshall(compActDef));
+ if (imports!=null) {
+ imports.write("<Resource name=\""+compActDef.getActName()+"\" "+(compActDef.getVersion()==-1?"":"version=\""+compActDef.getVersion()+"\" ")+"type=\"CA\">boot/CA/"+compActDef.getActName()+".xml</Resource>\n");
+ }
+ }
+ else {
+ FileStringUtility.string2File(new File(new File(dir, "EA"), actDef.getActName()+".xml"), Gateway.getMarshaller().marshall(actDef));
+ if (imports!=null) imports.write("<Resource name=\""+actDef.getActName()+"\" "+(actDef.getVersion()==-1?"":"version=\""+actDef.getVersion()+"\" ")+"type=\"EA\">boot/EA/"+actDef.getActName()+".xml</Resource>\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("<Resource name=\""+name+"\" "+(version==null?"":"version=\""+version+"\" ")+"type=\"SC\">boot/SC/"+name+".xml</Resource>\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("<Resource name=\""+name+"\" "+(version==null?"":"version=\""+version+"\" ")+"type=\"OD\">boot/OD/"+name+".xsd</Resource>\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<String, Object> mhm = new HashMap<String, Object>();
+ 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<String, Object> 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<Path> 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<Transition, String> 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<String, Object> mhm = new HashMap<String, Object>();
+ 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<String, Object> 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 ); }
+ }
+}
+
|