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

Go to download
package org.yaoqiang.graph.view;

import java.util.Map;

import com.mxgraph.model.mxCell;
import com.mxgraph.model.mxGeometry;
import com.mxgraph.model.mxIGraphModel;
import com.mxgraph.util.mxConstants;
import com.mxgraph.util.mxPoint;
import com.mxgraph.util.mxUtils;
import com.mxgraph.view.mxCellState;
import com.mxgraph.view.mxGraph;
import com.mxgraph.view.mxGraphView;

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

	public YGraphView(mxGraph graph) {
		super(graph);
	}

	public YGraph getGraph() {
		return (YGraph) graph;
	}
	
	public double getWordWrapWidth(mxCellState state)
	{
		Map style = state.getStyle();
		String shape = mxUtils.getString(style, mxConstants.STYLE_SHAPE, "label");
		if (shape.equals("event") || shape.equals("gateway") || shape.equals("dataobject") || shape.equals("datastore") || shape.equals("conversation")) {
			return 80;
		}				
		return super.getWordWrapWidth(state);
	}
	
	public void validateBounds(mxCellState parentState, Object cell)
	{
		mxIGraphModel model = graph.getModel();
		mxCellState state = getState(cell, true);

		if (state != null && state.isInvalid())
		{
			if (!graph.isCellVisible(cell))
			{
				removeState(cell);
			}
			else if (cell != currentRoot && parentState != null)
			{
				state.getAbsoluteOffset().setX(0);
				state.getAbsoluteOffset().setY(0);
				state.setOrigin(new mxPoint(parentState.getOrigin()));
				mxGeometry geo = graph.getCellGeometry(cell);

				if (geo != null)
				{
					if (!model.isEdge(cell))
					{
						mxPoint origin = state.getOrigin();
						mxPoint offset = geo.getOffset();

						if (offset == null)
						{
							offset = EMPTY_POINT;
						}

						if (geo.isRelative())
						{
							origin.setX(origin.getX() + geo.getX()
									* parentState.getWidth() / scale
									+ offset.getX());
							origin.setY(origin.getY() + geo.getY()
									* parentState.getHeight() / scale
									+ offset.getY());
						}
						else
						{
							state.setAbsoluteOffset(new mxPoint(scale
									* offset.getX(), scale * offset.getY()));
							origin.setX(origin.getX() + geo.getX());
							origin.setY(origin.getY() + geo.getY());
						}
					}

					// Updates the cell state's bounds
					state.setX(scale
							* (translate.getX() + state.getOrigin().getX()));
					state.setY(scale
							* (translate.getY() + state.getOrigin().getY()));
					state.setWidth(scale * geo.getWidth());
					state.setHeight(scale * geo.getHeight());

					if (model.isVertex(cell))
					{
						updateVertexLabelOffset(state);
					}

					// Updates the cached label
					updateLabel(state);
				}
			}

			// Applies child offset to origin
			mxPoint offset = graph.getChildOffsetForCell(cell);

			if (offset != null)
			{
				state.getOrigin()
						.setX(state.getOrigin().getX() + offset.getX());
				state.getOrigin()
						.setY(state.getOrigin().getY() + offset.getY());
			}
		}

		// Recursively validates the child bounds
		if (state != null
				&& (!graph.isCellCollapsed(cell) || cell == currentRoot))
		{
			// ==============start==============
			if (cell != currentRoot && ((mxCell) cell).getGeometry() != null && (getGraph().isCallActivityProcess(cell) || getGraph().isCollapsedSubProcess(cell) || getGraph().isCollapsedSwimlane(cell))) {
				int childCount = model.getChildCount(cell);
				for (int i = 0; i < childCount; i++) {
					Object child = model.getChildAt(cell, i);
					if (getGraph().isAttachedEvent(child)) {
						validateBounds(state, child);
					}
				}
			}
			// ==============end================
			else {
				int childCount = model.getChildCount(cell);
				for (int i = 0; i < childCount; i++) {
					Object child = model.getChildAt(cell, i);
					if (cell == currentRoot && getGraph().isAttachedEvent(child)) {
						continue;
					}
					validateBounds(state, child);
				}
			}
		}
	}
	
	public Object getVisibleTerminal(Object edge, boolean source)
	{
		mxIGraphModel model = graph.getModel();
		Object result = model.getTerminal(edge, source);
		Object best = result;

		while (result != null && result != currentRoot)
		{
			if (!graph.isCellVisible(best) || graph.isCellCollapsed(result) || getGraph().isCollapsedSubProcess(result))
			{
				best = result;
			}

			result = model.getParent(result);
		}

		// Checks if the result is not a layer
		if (model.getParent(best) == model.getRoot())
		{
			best = null;
		}

		return best;
	}
}