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

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

import org.yaoqiang.graph.model.GraphModel;
import org.yaoqiang.graph.swing.GraphComponent;
import org.yaoqiang.graph.util.GraphUtils;

import com.mxgraph.model.mxCell;
import com.mxgraph.util.mxEvent;
import com.mxgraph.util.mxEventObject;
import com.mxgraph.util.mxEventSource;

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

	protected GraphComponent graphComponent;

	protected Graph graph;

	protected GraphModel model;

	public SwimlaneManager(GraphComponent graphComponent) {
		if (this.graph != null) {
			this.graph.removeListener(handler);
		}

		this.graphComponent = graphComponent;
		this.graph = graphComponent.getGraph();
		this.model = graphComponent.getGraph().getModel();

		if (this.graph != null) {
			this.graph.addListener(null, handler);
		}
	}

	public final mxIEventListener getHandler() {
		return handler;
	}

	protected mxIEventListener handler = new mxIEventListener() {
		public void invoke(Object source, mxEventObject evt) {
			String eventName = evt.getName();
			if (evt.getName().equals(mxEvent.REPAINT) || evt.getName().equals(mxEvent.CONNECT_CELL) || evt.getName().equals(mxEvent.CELL_CONNECTED)
					|| evt.getName().equals(mxEvent.CHANGE) || evt.getName().equals(mxEvent.ORDER_CELLS) || evt.getName().equals(mxEvent.CELLS_ORDERED)) {
				return;
			}

			Object cell = graph.getSelectionCell();
			Object[] cells = (Object[]) evt.getProperty("cells");
			if (cell == null) {
				if (cells != null && cells.length > 0) {
					cell = (mxCell) cells[0];
				}
			}
			if (!graph.isSwimlane(cell) && !eventName.equals(mxEvent.ROOT) && !eventName.equals(mxEvent.MOVE_CELLS) && !eventName.equals(mxEvent.FOLD_CELLS) && !eventName.equals(mxEvent.RESIZE_CELLS)) {
				return;
			}

			if (eventName.equals(mxEvent.RESIZE_CELLS) || (!graph.isSwimlane(cell) && eventName.equals(mxEvent.FOLD_CELLS))) {
				model.beginUpdate();
				try {
					if (!graph.isSwimlane(cell)) {
						cell = graph.getParentSwimlane(cell);
					}
					if (cell != null) {
						GraphUtils.arrangeSwimlanePosition(graphComponent);
						GraphUtils.arrangeSwimlaneLength(graph, cell, false, false);
						GraphUtils.manualArrangeSwimlaneLength(graph, cell);
						GraphUtils.arrangeSwimlaneSize(graph, cell, false, false, true);
					}
				} finally {
					model.endUpdate();
				}
			} else if (eventName.equals(mxEvent.REMOVE_CELLS)) {
				for (Object pool : graph.getAllPools()) {
					GraphUtils.arrangeSwimlaneSize(graph, pool, false, false, false);
				}
				GraphUtils.arrangeSwimlanePosition(graphComponent);
			} else if (eventName.equals(mxEvent.FOLD_CELLS)) {
				model.beginUpdate();
				try {
					GraphUtils.arrangeSwimlaneLength(graph, cell, false, true);
					GraphUtils.manualArrangeSwimlaneLength(graph, cell);
					GraphUtils.arrangeSwimlaneSize(graph, cell, false, true, false);
					if (graph.isManualPool(model.getParent(cell))) {
						if (graph.isVerticalSwimlane(model.getParent(cell))) {
							GraphUtils.arrangeLaneXOffset(graph, model.getParent(cell));
						} else {
							GraphUtils.arrangeLaneYOffset(graph, model.getParent(cell));
						}
					} else {
						GraphUtils.arrangeSwimlanePosition(graphComponent);
					}
				} finally {
					model.endUpdate();
				}
			} else if (eventName.equals(mxEvent.UNDO) || eventName.equals(mxEvent.REDO)) {
				GraphUtils.arrangeSwimlaneLength(graph, cell, true, false);
				GraphUtils.manualArrangeSwimlaneLength(graph, cell);
				GraphUtils.arrangeSwimlaneSize(graph, cell, false, false, false);
				if (graph.isVerticalSwimlane(cell)) {
					GraphUtils.arrangeLaneXOffset(graph, model.getParent(cell));
				} else {
					GraphUtils.arrangeLaneYOffset(graph, model.getParent(cell));
				}
				GraphUtils.arrangeSwimlanePosition(graphComponent);
			} else if (eventName.equals(mxEvent.MOVE_CELLS)) {
				Object targetCell = evt.getProperty("target");
				if ((targetCell == null || graph.isPlane(targetCell) || graph.isSwimlane(targetCell)) && graph.isSwimlane(cells[0])) {
					GraphUtils.arrangeSwimlaneLength(graph, cells[0], true, false);
					GraphUtils.manualArrangeSwimlaneLength(graph, cells[0]);
					GraphUtils.arrangeSwimlaneSize(graph, cells[0], false, false, false);
					GraphUtils.arrangeSwimlanePosition(graphComponent);
				} else if (graph.isSwimlane(targetCell) && !graph.isSwimlane(cells[0])) {
					GraphUtils.arrangeSwimlaneSize(graph, targetCell, false, false, false);
					GraphUtils.arrangeSwimlanePosition(graphComponent);
				}
			} else if (eventName.equals(mxEvent.ROOT)) {
				for (Object pool : graph.getAllPools()) {
					GraphUtils.arrangeSwimlaneLength(graph, pool, true, false);
					GraphUtils.manualArrangeSwimlaneLength(graph, pool);
					GraphUtils.arrangeSwimlaneSize(graph, pool, false, true, false);
					GraphUtils.arrangeSwimlanePosition(graphComponent);
				}
			} else if (eventName.equals(mxEvent.CELLS_ADDED)) {
				Object parent = evt.getProperty("parent");
				if (parent != null) {
					if (graph.isVerticalSwimlane(cell)) {
						GraphUtils.arrangeLaneXOffset(graph, parent);
					} else {
						GraphUtils.arrangeLaneYOffset(graph, parent);
					}
				}
			}

			graph.refresh();
		}
	};

}