• Home
• net.sourceforge.bpmn
• yaoqiang-bpmn-editor
• 2.0.112
• source code
• YGraph.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.YGraph Maven / Gradle / Ivy

package org.yaoqiang.graph.view;

import java.awt.Point;
import java.text.NumberFormat;
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.graph.model.YGraphModel;
import org.yaoqiang.graph.util.Constants;
import org.yaoqiang.graph.util.TooltipBuilder;
import org.yaoqiang.graph.util.Utils;

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.mxRectangle;
import com.mxgraph.util.mxResources;
import com.mxgraph.util.mxUtils;
import com.mxgraph.view.mxCellState;
import com.mxgraph.view.mxGraph;

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

	public static final NumberFormat numberFormat = NumberFormat.getInstance();

	protected TooltipBuilder tooltipBuilder;

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

		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 YGraphModel getModel() {
		return (YGraphModel) model;
	}

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

	protected YGraphView createGraphView() {
		return new YGraphView(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;
			}
		}
		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;
			}
			if (newValue.toString().length() == 0 && isLinkEvent(cell)) {
				JOptionPane.showMessageDialog(null, mxResources.get("WarningLinkEventMustHaveAName"), "Validation Error!", JOptionPane.WARNING_MESSAGE);
				return;
			}
			if (value.equals(newValue)) {
				return;
			}
			model.beginUpdate();

			if (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 && hasParticipantRef((mxCell) cell, partId)) {
					option = JOptionPane.showConfirmDialog(null, mxResources.get("InfoYesToRenameSelectedParticipantOrNoToCreateNewParticipant"),
							mxResources.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.setId(actId + "_part_" + newPartId);
						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 {
						Map participantCells = 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, mxResources.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 (!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 (isLane(cell) && model.getChildCount(model.getParent(cell)) > 1) {
			return true;
		}
		return false;
	}

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

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

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

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

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

	public boolean isExtendParent(Object cell) {
		return !model.isEdge(cell) && !isCallActivityProcess(model.getParent(cell)) && isExtendParents();
	}

	public boolean isCellMovable(Object cell) {
		if (isChoreographyTask(cell) || isChoreographySubprocess(cell) || isChoreographyParticipant(cell) || isOrganizationName(cell)) {
			return false;
		}
		return super.isCellMovable(cell) || isAttachedEvent(cell) || 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 (isSubProcess(cell) && isSwimlane(cells[0])) {
			return false;
		}
		if (model.isCollapsed(cell) && isSwimlane(cell)) {
			return false;
		}
		if ((isTask(cell) || isCallActivityProcess(cell) || isCollapsedSubProcess(cell))
				&& (getConnections(cells[0]).length > 0 || isLinkEvent(cells[0]) || isThrowEvent(cells[0]) && !isNoneEvent(cells[0]))) {
			return false;
		}
		if ((isTask(cell) || isCallActivityProcess(cell)) && (model.getChildCount(cell) > 3 || !isIntermediateEvent(cells[0]) || cells.length > 1)) {
			return false;
		}
		if (isCollapsedSubProcess(cell)
				&& (!isEvent(cells[0]) || isStartEvent(cells[0]) && !isNoneEvent(cells[0]) || isThrowEvent(cells[0]) && !isEndEvent(cells[0])
						&& !isNoneEvent(cells[0]))) {
			return false;
		}
		if (isCollapsedSubProcess(cell) && isChoreographySubprocess(cell)) {
			return false;
		}
		if (isReceiveTask(cell) && isIntermediateEvent(cells[0])) {
			Object[] edges = getIncomingEdges(cell);
			if (edges.length > 0 && isEventGateway(model.getTerminal(edges[0], true))) {
				return false;
			}
		}

		if (isAttachedEvent(cells[0]) && model.getParent(cells[0]) != cell) {
			return false;
		}
		if (isGroupArtifact(cells[0]) && !isSubProcess(cell) && !isSubChoreography(cell)) {
			return false;
		}
		if (isAnnotation(cells[0]) || (isChoreography(cells[0]) || isSubChoreography(cells[0]))
				&& (!isChoreographySubprocess(cell) || isChoreographySubprocess(cell) && model.isAncestor(cells[0], cell))) {
			return false;
		}
		if (!isChoreographyParticipant(cells[0]) && !isChoreographySubprocess(cells[0]) && !isChoreographyTask(cells[0])
				&& (isChoreography(cell) || isSubChoreography(cell))) {
			return false;
		}
		if (!isGroupArtifact(cells[0]) && !isEvent(cells[0]) && !isGateway(cells[0]) && !isMessage(cells[0]) && !isChoreography(cells[0])
				&& !isSubChoreography(cells[0]) && isChoreographySubprocess(cell)) {
			return false;
		}
		if (cells != null) {
			for (int i = 0; i < cells.length; i++) {
				if (isSubChoreography(cells[i]) && isChoreographySubprocess(cell) && model.isAncestor(cells[i], cell))
					return false;
				if (isSubProcess(cells[i]) && 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) && isConversation(cells[0])) {
			return false;
		}
		if (!isMessageFlow(cell) && !isPlane(cell) && !isChoreographySubprocess(cell) && isMessage(cells[0])) {
			return false;
		}
		if (isMessageFlow(cell) && model.getChildCount(cell) > 0) {
			return false;
		}
		return cell != null
				&& cells != null
				&& cell != cells[0]
				&& ((isSplitEnabled() && isSplitTarget(cell, cells)) || isMessageFlow(cell) && isMessage(cells[0]) || (!model.isEdge(cell) && (isSwimlane(cell)
						|| isTask(cell) && isIntermediateEvent(cells[0]) || isCallActivityProcess(cell) && isIntermediateEvent(cells[0]) || isSubProcess(cell) || (model
						.getChildCount(cell) > 0 && !isCellCollapsed(cell)))));
	}

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

	}

	public Object splitEdge(Object edge, Object[] cells, double dx, double dy) {
		if (isMessage(cells[0])) {
			return null;
		}
		if (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 (isSubProcess(group)) {
				if (result.getWidth() <= Constants.FOLDED_SUBPROCESS_WIDTH) {
					result.setWidth(Constants.FOLDED_SUBPROCESS_WIDTH);
				}
			}

			// 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[] getCellsForGroup(Object[] cells) {
		List