• Home
• net.sourceforge.bpmn
• yaoqiang-bpmn-editor
• 2.1.12
• source code
• Graph.java

×

Project download

Many resources are needed to download a project. Please understand that we have to compensate our server costs. Thank you in advance.
Project price only 1 $

You can buy this project and download/modify it how often you want.

org.yaoqiang.graph.view.Graph Maven / Gradle / Ivy

package org.yaoqiang.graph.view;

import java.awt.Point;
import java.util.ArrayList;
import java.util.Arrays;
import java.util.Collection;
import java.util.Collections;
import java.util.Comparator;
import java.util.HashMap;
import java.util.HashSet;
import java.util.Hashtable;
import java.util.List;
import java.util.Map;
import java.util.Map.Entry;
import java.util.Set;

import javax.swing.JOptionPane;

import org.w3c.dom.Element;
import org.yaoqiang.bpmn.model.BPMNModelUtils;
import org.yaoqiang.bpmn.model.elements.XMLElement;
import org.yaoqiang.bpmn.model.elements.activities.SubProcess;
import org.yaoqiang.bpmn.model.elements.artifacts.Association;
import org.yaoqiang.bpmn.model.elements.artifacts.Group;
import org.yaoqiang.bpmn.model.elements.artifacts.TextAnnotation;
import org.yaoqiang.bpmn.model.elements.collaboration.Participant;
import org.yaoqiang.bpmn.model.elements.core.common.FlowNode;
import org.yaoqiang.bpmn.model.elements.core.foundation.BaseElement;
import org.yaoqiang.bpmn.model.elements.core.infrastructure.Definitions;
import org.yaoqiang.bpmn.model.elements.data.DataAssociation;
import org.yaoqiang.bpmn.model.elements.data.DataInput;
import org.yaoqiang.bpmn.model.elements.data.DataObject;
import org.yaoqiang.bpmn.model.elements.data.DataObjectReference;
import org.yaoqiang.bpmn.model.elements.data.DataOutput;
import org.yaoqiang.bpmn.model.elements.data.DataStoreReference;
import org.yaoqiang.bpmn.model.elements.data.ItemAwareElement;
import org.yaoqiang.graph.model.GraphModel;
import org.yaoqiang.graph.util.GraphUtils;
import org.yaoqiang.graph.util.TooltipBuilder;
import org.yaoqiang.util.Constants;
import org.yaoqiang.util.Resources;

import com.mxgraph.model.mxCell;
import com.mxgraph.model.mxGeometry;
import com.mxgraph.model.mxGraphModel;
import com.mxgraph.model.mxICell;
import com.mxgraph.util.mxConstants;
import com.mxgraph.util.mxEvent;
import com.mxgraph.util.mxEventObject;
import com.mxgraph.util.mxPoint;
import com.mxgraph.util.mxRectangle;
import com.mxgraph.util.mxUtils;
import com.mxgraph.view.mxCellState;
import com.mxgraph.view.mxGraph;

/**
 * Graph
 * 
 * @author Shi Yaoqiang([email protected])
 */
public class Graph extends mxGraph {

	protected Map bpmnElementMap = new HashMap();

	protected Map externalDefinitions = new HashMap();

	protected TooltipBuilder tooltipBuilder;

	public Graph(mxGraphModel model) {
		super(model, null);

		setVertexLabelsMovable(true);
		setResetViewOnRootChange(false);
		setDisconnectOnMove(false);
		setAllowDanglingEdges(false);
		setResetEdgesOnConnect(false);
		setMultigraph(false);
		setConnectableEdges(Constants.SETTINGS.getProperty("connectableEdge", "0").equals("1"));
		setCellsDisconnectable(false);
		setKeepEdgesInForeground(true);
		setGridSize(Integer.parseInt(Constants.SETTINGS.getProperty("gridSize", "5")));

		this.tooltipBuilder = new TooltipBuilder();
	}

	public final Definitions getBpmnModel() {
		return getModel().getBpmnModel();
	}

	public Map getBpmnElementMap() {
		return bpmnElementMap;
	}

	public void clearBpmnModel() {
		getBpmnModel().clear();
		externalDefinitions.clear();
		bpmnElementMap.clear();
		getBpmnModel().setName("");
	}

	public final void setBpmnElementMap(Map bpmnElementMap) {
		this.bpmnElementMap = bpmnElementMap;
	}

	public Map getExternalDefinitions() {
		return externalDefinitions;
	}

	public GraphModel getModel() {
		return (GraphModel) model;
	}

	public GraphView getView() {
		return (GraphView) view;
	}

	protected GraphView createGraphView() {
		return new GraphView(this);
	}

	public String getToolTipForCell(Object cell) {
		return tooltipBuilder.getTooltip(this, (mxCell) cell);
	}

	public String convertValueToString(Object cell) {
		if (cell instanceof mxCell) {
			Object value = ((mxCell) cell).getValue();
			String name = null;
			if (value instanceof Element) {
				Element elt = (Element) value;
				if (isOrganizationElement(cell)) {
					name = elt.getAttribute("cn");
					if (isOrganization(cell) || isOrganizationRoot(cell)) {
						name = elt.getAttribute("o");
					} else if (isOrganizationalUnit(cell)) {
						name = elt.getAttribute("ou");
					}
				} else {
					name = elt.getAttribute("value");
				}
				return name;
			} else if (value instanceof BaseElement) {
				if (value instanceof TextAnnotation) {
					return ((BaseElement) value).get("text").toValue();
				} else if (value instanceof Group) {
					return BPMNModelUtils.getCategoryValueString(getBpmnModel(), ((Group) value).getCategoryValueRef());
				} else if (value instanceof Association || value instanceof DataAssociation) {
					return "";
				} else if (value instanceof DataStoreReference) {
					String dsRef = ((DataStoreReference) value).getDataStoreRef();
					if (dsRef.length() == 0) {
						return "";
					} else {
						return getBpmnModel().getDataStore(dsRef).getName();
					}
				} else if (value instanceof ItemAwareElement) {
					String dataState = null;
					if (value instanceof DataObjectReference) {
						DataObject obj = ((DataObjectReference) value).getRefDataObject();
						if (obj == null) {
							return "";
						} else {
							name = obj.getName();
							dataState = obj.getDataState();
						}
					} else if (value instanceof DataInput || value instanceof DataOutput) {
						name = ((BaseElement) value).get("name").toValue();
						dataState = ((ItemAwareElement) value).getDataState();
					}
					if (dataState == null || dataState.length() == 0) {
						return name;
					} else {
						return name + "\n[" + dataState + "]";
					}
				}
				return ((BaseElement) value).get("name").toValue();
			}
		}
		return super.convertValueToString(cell);
	}

	public void cellLabelChanged(Object cell, Object newValue, boolean autoSize) {
		if (cell instanceof mxCell && newValue != null) {
			Object value = ((mxCell) cell).getValue();

			if (value instanceof Element) {
				String label = newValue.toString();
				Element elt = (Element) value;

				// Clones the value for correct undo/redo
				elt = (Element) elt.cloneNode(true);
				String attrName = "value";
				if (isOrganizationElement(cell)) {
					attrName = "cn";
					if (isOrganization(cell) || isOrganizationRoot(cell)) {
						attrName = "o";
					} else if (isOrganizationalUnit(cell)) {
						attrName = "ou";
					}
				}
				elt.setAttribute(attrName, label);
				newValue = elt;
			} else if (value instanceof BaseElement && newValue instanceof String) {
				String label = newValue.toString();
				BaseElement baseElement = (BaseElement) ((BaseElement) value).clone();
				if (value instanceof TextAnnotation) {
					baseElement.set("text", label);
				} else if (value instanceof ItemAwareElement) {
					int index = label.lastIndexOf("\n[");
					if (index > 0) {
						String name = label.substring(0, index);
						String state = label.substring(index + 2, label.length() - 1);
						baseElement.set("name", name);
						((ItemAwareElement) baseElement).setDataState(state);
					} else {
						baseElement.set("name", label);
						((ItemAwareElement) baseElement).setDataState("");
					}

				} else {
					baseElement.set("name", label);
				}
				newValue = baseElement;
			}
			if (newValue.toString().length() == 0 && getModel().isLinkEvent(cell)) {
				JOptionPane.showMessageDialog(null, Resources.get("WarningLinkEventMustHaveAName"), "Validation Error!", JOptionPane.WARNING_MESSAGE);
				return;
			}
			if (!(value instanceof BaseElement) && value.equals(newValue)) {
				return;
			}
			model.beginUpdate();

			if (getModel().isChoreographyParticipant(cell)) {
				int index = ((mxCell) cell).getId().indexOf("_part_");
				String partId = ((mxCell) cell).getId().substring(index + 6);
				String actId = ((mxCell) cell).getId().substring(0, index);

				int option = JOptionPane.YES_OPTION;
				Map participants = getAllParticipants();
				if (participants.get(newValue) == null && getModel().hasParticipantRef((mxCell) cell, partId)) {
					option = JOptionPane.showConfirmDialog(null, Resources.get("InfoYesToRenameSelectedParticipantOrNoToCreateNewParticipant"),
							Resources.get("InfoRenameOrCreate"), JOptionPane.YES_NO_OPTION);
					if (option == JOptionPane.NO_OPTION) {
						String newPartId = getModel().createId(cell);
						mxCell newCell = (mxCell) model.cloneCells(new Object[] { cell }, false)[0];
						newCell.setValue(new Participant(newValue.toString()));
						newCell.setId(actId + "_part_" + newPartId);
						newCell.setParent(null);
						Object parent = ((mxCell) cell).getParent();
						removeCells(new Object[] { cell });
						addCell(newCell, parent);
						if (this.isAdditionalChoreographyParticipant(newCell)) {
							orderCells(false, new Object[] { newCell });
						} else {
							orderCells(true, new Object[] { newCell });
						}
						cell = newCell;
					} else {
						Map participantCells = getModel().getAllChoreographyParticipants();
						for (Entry part : participantCells.entrySet()) {
							if (part.getKey().endsWith(partId)) {
								model.setValue(part.getValue(), newValue);
							}
						}
					}
				} else if (participants.get(newValue) != null) {
					String newPartId = participants.get(newValue);
					mxCell newCell = (mxCell) model.cloneCells(new Object[] { cell }, false)[0];
					newCell.setId(actId + "_part_" + newPartId);
					if (getModel().getCell(newCell.getId()) != null) {
						JOptionPane.showMessageDialog(null, Resources.get("WarningSubChoreographyMustNotInvolveDuplicatedParticipants"), "Validation Error!",
								JOptionPane.WARNING_MESSAGE);
						return;
					}
					newCell.setParent(null);
					newCell.setValue(newValue);
					removeCells(new Object[] { cell });
					addCell(newCell, ((mxCell) cell).getParent());
					if (this.isAdditionalChoreographyParticipant(newCell)) {
						orderCells(false, new Object[] { newCell });
					} else {
						orderCells(true, new Object[] { newCell });
					}
					cell = newCell;
				} else if (!getModel().hasParticipantRef((mxCell) cell, partId)) {
					model.setValue(cell, newValue);
				}
			} else {
				model.setValue(cell, newValue);
			}

			model.endUpdate();
		}

		if (newValue != null) {
			fireEvent(new mxEventObject(mxEvent.LABEL_CHANGED, "cells", new Object[] { cell }));
		}
	}

	public boolean isLaneMovable(Object cell) {
		if (getModel().isLane(cell) && model.getChildCount(model.getParent(cell)) > 1) {
			return true;
		}
		return false;
	}

	public boolean isLabelMovable(Object cell) {
		return !isCellLocked(cell)
				&& ((model.isEdge(cell) && isEdgeLabelsMovable()) || ((getModel().isGateway(cell) || getModel().isEvent(cell) || getModel().isDataObject(cell)
						|| getModel().isDataInput(cell) || getModel().isDataOutput(cell) || getModel().isDataStore(cell) || getModel().isConversationNode(cell)
						|| getModel().isMessage(cell) || isImageArtifact(cell)) && isVertexLabelsMovable()));
	}

	public boolean isCellSelectable(Object cell) {
		return isCellsSelectable() && !getModel().isChoreographyTask(cell) && !getModel().isChoreographySubprocess(cell)
				&& !getModel().isChoreographyParticipant(cell) && !isOrganizationName(cell);
	}

	public boolean isCellCollapsed(Object cell) {
		return isCollapsedSwimlane(cell) || model.isCollapsed(cell);
	}

	public boolean isCellEditable(Object cell) {
		if (getModel().isAssociation(cell) || getModel().isDataAssociation(cell) || isOrganizationName(cell)) {
			return false;
		}
		return true;
	}

	public boolean isCellResizable(Object cell) {
		if (((mxCell) cell).getStyle() != null
				&& (getModel().isLane(cell) && hasChildLane(cell) || isAutoPool(cell) && hasChildLane(cell) || getModel().isDataObject(cell)
						|| getModel().isDataInput(cell) || getModel().isDataOutput(cell) || getModel().isDataStore(cell) || getModel().isMessage(cell)
						|| getModel().isChoreographyTask(cell) || getModel().isChoreographySubprocess(cell) || getModel().isChoreographyParticipant(cell)
						|| getModel().isConversationNode(cell) || getModel().isEvent(cell) || getModel().isGateway(cell) || isOrganizationName(cell) || isOrganizationElement(cell))) {
			return false;
		}
		return super.isCellResizable(cell);
	}

	public boolean isCellFoldable(Object cell, boolean collapse) {
		return (!getModel().isCallActivity(cell) && !isSubChoreography(cell) && !isChoreography(cell) && !getModel().isTask(cell))
				&& !getModel().isMessageFlow(cell) && model.getChildCount(cell) > 0 || getModel().isSubProcess(cell)
				|| getModel().isChoreographySubprocess(cell) || isSwimlane(cell);
	}

	public boolean isCellMovable(Object cell) {
		if (getModel().isLane(cell) && model.getChildCount(cell) > 1 || getModel().isChoreographyTask(cell) || getModel().isChoreographySubprocess(cell)
				|| getModel().isChoreographyParticipant(cell) || isOrganizationName(cell)) {
			return false;
		}
		return super.isCellMovable(cell) || getModel().isBoundaryEvent(cell) || getModel().isMessage(cell);
	}

	public boolean isValidDropTarget(Object cell, Object[] cells) {
		if (cells == null) {
			cells = getSelectionCells();
		}
		if (hasChildNonLane(cell) && isSwimlane(cells[0]) && model.getParent(cells[0]) != cell) {
			return false;
		}
		if (hasChildLane(cell) && !isSwimlane(cells[0])) {
			return false;
		}
		if (getModel().isSubProcess(cell) && isSwimlane(cells[0])) {
			return false;
		}
		if (model.isCollapsed(cell) && isSwimlane(cell)) {
			return false;
		}
		if (isSwimlane(cell) && getModel().isPool(cells[0])) {
			return false;
		}
		if (getModel().isChoreographyTask(cell) || getModel().isCollapsedSubProcess(cell) && getModel().isChoreographySubprocess(cell)) {
			return false;
		}
		if ((getModel().isTask(cell) || getModel().isCallActivity(cell) || getModel().isCollapsedSubProcess(cell))
				&& (getConnections(cells[0]).length > 0 || getModel().isLinkEvent(cells[0]) || getModel().isThrowEvent(cells[0]))) {
			return false;
		}
		if ((getModel().isTask(cell) || getModel().isCallActivity(cell))
				&& (model.getChildCount(cell) > 3 || !getModel().isIntermediateEvent(cells[0]) || cells.length > 1)) {
			return false;
		}
		if (getModel().isCollapsedSubProcess(cell)
				&& (!getModel().isEvent(cells[0]) || getModel().isStartEvent(cells[0]) && !getModel().isNoneEvent(cells[0]) || getModel()
						.isThrowEvent(cells[0]) && !getModel().isEndEvent(cells[0]) && !getModel().isNoneEvent(cells[0]))) {
			return false;
		}
		if (getModel().isReceiveTask(cell) && getModel().isIntermediateEvent(cells[0])) {
			Object[] edges = getIncomingEdges(cell);
			if (edges.length > 0 && getModel().isEventGateway(model.getTerminal(edges[0], true))) {
				return false;
			}
		}

		if (getModel().isBoundaryEvent(cells[0]) && model.getParent(cells[0]) != cell) {
			return false;
		}
		if (getModel().isGroupArtifact(cells[0]) && !getModel().isSubProcess(cell) && !isSubChoreography(cell)) {
			return false;
		}
		if (getModel().isAnnotation(cells[0]) || (isChoreography(cells[0]) || isSubChoreography(cells[0]))
				&& (!getModel().isChoreographySubprocess(cell) || getModel().isChoreographySubprocess(cell) && model.isAncestor(cells[0], cell))) {
			return false;
		}
		if (!getModel().isChoreographyParticipant(cells[0]) && !getModel().isChoreographySubprocess(cells[0]) && !getModel().isChoreographyTask(cells[0])
				&& (isChoreography(cell) || isSubChoreography(cell))) {
			return false;
		}
		if (!getModel().isGroupArtifact(cells[0]) && !getModel().isEvent(cells[0]) && !getModel().isGateway(cells[0]) && !getModel().isMessage(cells[0])
				&& !isChoreography(cells[0]) && !isSubChoreography(cells[0]) && getModel().isChoreographySubprocess(cell)) {
			return false;
		}
		if (cells != null) {
			for (int i = 0; i < cells.length; i++) {
				if (isSubChoreography(cells[i]) && getModel().isChoreographySubprocess(cell) && model.isAncestor(cells[i], cell))
					return false;
				if (getModel().isSubProcess(cells[i]) && getModel().isSubProcess(cell) && model.isAncestor(cells[i], cell))
					return false;
				if (isSwimlane(cells[i]) && isSwimlane(cell) && model.isAncestor(cells[i], cell))
					return false;
			}
		}

		if (!isPlane(cell) && getModel().isConversationNode(cells[0])) {
			return false;
		}
		if (!getModel().isMessageFlow(cell) && !isPlane(cell) && !getModel().isChoreographySubprocess(cell) && getModel().isMessage(cells[0])) {
			return false;
		}
		if (getModel().isMessageFlow(cell) && model.getChildCount(cell) > 0) {
			return false;
		}
		return cell != null
				&& cells != null
				&& cell != cells[0]
				&& ((isSplitEnabled() && isSplitTarget(cell, cells)) || getModel().isMessageFlow(cell) && getModel().isMessage(cells[0]) || (!model
						.isEdge(cell) && (isSwimlane(cell) || getModel().isTask(cell) && getModel().isIntermediateEvent(cells[0])
						|| getModel().isCallActivity(cell) && getModel().isIntermediateEvent(cells[0]) || getModel().isSubProcess(cell)
						|| getModel().isChoreographySubprocess(cell) || (model.getChildCount(cell) > 0 && !isCellCollapsed(cell)))));
	}

	public boolean isSplitTarget(Object target, Object[] cells) {
		if (getModel().isMessageFlow(target) || isCompensationAssociation(target) || getModel().isDataAssociation(target) || getModel().isAssociation(target)) {
			return false;
		}
		if (cells == null || cells.length != 1 || getModel().isArtifact(cells[0]) || isSwimlane(cells[0]) || getModel().isStartEvent(cells[0])
				|| getModel().isEndEvent(cells[0]) || getModel().isDataObject(cells[0]) || getModel().isDataInput(cells[0])
				|| getModel().isDataOutput(cells[0]) || getModel().isDataStore(cells[0])) {
			return false;
		}
		return super.isSplitTarget(target, cells);

	}

	public Object splitEdge(Object edge, Object[] cells, double dx, double dy) {
		if (getModel().isMessage(cells[0])) {
			return null;
		}
		if (getModel().isSubProcess(cells[0])) {
			mxGeometry geo = ((mxICell) cells[0]).getGeometry();
			geo.setAlternateBounds(new mxRectangle(0, 0, Constants.ACTIVITY_WIDTH, Constants.ACTIVITY_HEIGHT));
			model.setGeometry(cells[0], geo);
			foldCells(true, false, new Object[] { cells[0] });
		}

		Object parent = model.getParent(edge);
		Object source = model.getTerminal(edge, true);
		Object target = model.getTerminal(edge, false);

		model.beginUpdate();
		try {
			cellsMoved(cells, dx, dy, false, false);
			cellsAdded(cells, parent, model.getChildCount(parent), null, null, true);
			Object leftEdge = cloneCells(new Object[] { edge })[0];
			Object rightEdge = cloneCells(new Object[] { edge })[0];
			cellsAdded(new Object[] { leftEdge }, parent, model.getChildCount(parent), source, cells[0], false);
			cellsAdded(new Object[] { rightEdge }, parent, model.getChildCount(parent), cells[0], target, false);
			removeCells(new Object[] { edge }, true);
			fireEvent(new mxEventObject(mxEvent.SPLIT_EDGE, "edge", edge, "cells", cells, "dx", dx, "dy", dy));
		} finally {
			model.endUpdate();
		}

		return edge;
	}

	public mxRectangle getBoundsForGroup(Object group, Object[] children, double border) {
		mxRectangle result = getBoundingBoxFromGeometry(children);

		if (result != null) {
			if (isSwimlane(group)) {
				mxRectangle size = getStartSize(group);

				result.setX(result.getX() - size.getWidth());
				result.setY(result.getY() - size.getHeight());
				result.setWidth(result.getWidth() + size.getWidth());
				result.setHeight(result.getHeight() + size.getHeight());
			} else if (getModel().isSubProcess(group)) {
				if (result.getWidth() <= Constants.FOLDED_SUBPROCESS_WIDTH) {
					result.setWidth(Constants.FOLDED_SUBPROCESS_WIDTH);
				}
				if (result.getHeight() <= Constants.FOLDED_SUBPROCESS_HEIGHT) {
					result.setHeight(Constants.FOLDED_SUBPROCESS_HEIGHT);
				}
			}

			// Adds the border
			result.setX(result.getX() - border);
			result.setY(result.getY() - border);
			result.setWidth(result.getWidth() + 2 * border);
			result.setHeight(result.getHeight() + 2 * border);
		}

		return result;
	}

	public Object groupCells(Object group, double border, Object[] cells) {
		if (cells == null) {
			cells = mxUtils.sortCells(getSelectionCells(), true);
		}

		cells = getCellsForGroup(cells);

		if (group == null) {
			group = createGroupCell(cells);
		}

		mxRectangle bounds = getBoundsForGroup(group, cells, border);

		if (cells.length > 0 && bounds != null) {
			// Uses parent of group or previous parent of first child
			Object parent = model.getParent(group);

			if (parent == null) {
				parent = model.getParent(cells[0]);
			}

			model.beginUpdate();
			try {
				// Checks if the group has a geometry and
				// creates one if one does not exist
				if (getCellGeometry(group) == null) {
					model.setGeometry(group, new mxGeometry());
				}

				// Adds the children into the group and moves
				int index = model.getChildCount(group);
				cellsAdded(cells, group, index, null, null, false);
				cellsMoved(cells, -bounds.getX(), -bounds.getY(), false, true);

				// Adds the group into the parent and resizes
				index = model.getChildCount(parent);
				cellsAdded(new Object[] { group }, parent, index, null, null, false, false);
				cellsResized(new Object[] { group }, new mxRectangle[] { bounds });

				// ==============start==============
				for (Object cell : cells) {
					if (model.isVertex(cell)) {
						List